Test on 11/24/2018

偶然间最糟糕的再会

Description

一天Murphyc从睡梦中醒来，发现自己居然穿越到了弹丸论破的世界。作为原作全成就通关的超高校级Gamer，Murphyc很清楚接下来会发生什么。为了中止Chiaki即将面临的“学级裁判”，Murphyc溜进了未来机关内部，但是只有持有特定编号的识别卡才能进入机关控制室。

好在，Murphyc其实还有另一重身份----法师学徒！虽然Murphyc手中只有门口警卫的识别卡，但机智的他发现该警卫的识别卡编号只要经过若干次Magic操作便可变为原作CG中某重要角色Chisa的的识别码。

Magic操作：对于i与j位置的两个数字你可以消耗|i-j|的魔力值以交换两个数字的位置。

例如

现在已知警卫的识别码为一个长度为n的整数序列a,ai<=n, Chisa的识别码为长度为n的整数序列b,bi<=n,并且，a、b序列均为[1,n]的全排列之一.为了节约魔力，请问Murphyc至少要消耗多少魔力才能获得Chisa的识别码？

Input

第一行一个数字T代表测试的组数(T<=20)

对于每组测试，第一行一个数字n代表序列的长度(n<=2e5)

接下来一行有n个数字a1,a2,a3….an(1<=ai<=n)

接下来一行有n个数字b1,b2,b3…bn(1<=bi<=n)

Output

对于每行输出一个整数

Examples

Input

1
4
2 3 4 1
1 3 4 2

Output

3

 

正确解法：

官方题解：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int a[200005],b[200005];
int conv[200005];
int main()
{
    freopen("stdin.txt","r",stdin);
    freopen("stdout.txt","w",stdout);
    int zu;
    scanf("%d",&zu);
    while(zu--)
    {
        int n;
        scanf("%d",&n);
        for(int i=1;i<=n;i++) scanf("%d",&a[i]),conv[a[i]]=i;
        for(int i=1;i<=n;i++) scanf("%d",&b[i]);
        ll ans=0;
        for(int i=1;i<=n;i++) ans+=abs(i-conv[b[i]]);
        printf("%lld\n",ans/2);
    }
}

（为什么这样写我也不知道qaq）

 

01串

Description

现在我们有一个由01组成的字符串。我们需要在上面做一些操作。每次我们都选一个“01”子串，把他替换成110。如果找不到“01”子串，那么操作结束。请输出总共进行了多少次操作，结果请mod 1e9+7。

Ps：“01”子串必须是相邻的0和1，字符串中只包含0和1。

Input

首先一个T，代表接下来有T行。

接下来的T行，每行一个字符串str

（1<= T <= 200, 所有字符串长度和 len <= 2e7）

Output

对于每个字符串，输出相应操作数。

Examples

Input

2
01
001

Output

1
3

 

正确解法：

每个字符串都会变成前面是1，后面是0，若在1前面有一个0，那么需要1次。有两个0，需要3次，有n个0，需要（2*n-1）次，若有两个1，你会发现，第一个1变化后，所以第一个1前面的0都变到了第二个1的前面。

所有就统计0个个数，遇到1就加一次。

 

 

粗题⼈不考你没学过的算法

Description

粗题⼈症重承诺此题不考你没学过的算法

给你⼀个区间[L,R]

需要选择N个数，这N个数都在这个区间范围内

那么我们知道⼀共有[R-L+1]^N种选法

假如我们想要这N个数的最⼤公约数恰好是K

请问⼀共有多少种选法，输出答案对1e9+7取模

Input

 多组测试数据 对于每组数据，输⼊⼀⾏包含4个整数N,K,L,R(1<=N,K,L<=10^9,L<=R<=10^9)

(0<=R-L<=10^5)

Output

对于每行输出一个整数

Examples

Input

2 2 2 4
2 100 2 4
1 5 5 5
73824 17347 9293482 9313482
222 222 222 22222

Output

3
0
1
0
339886855

 

正确解法：

不会qaq 挖坑。

#include <iostream> 
#include <fstream> 
#include <sstream> 
#include <cstdio> 
#include <cstring> 
#include <cstdlib> 
#include <cmath> 
#include <ctime> 
#include <algorithm> 
#include <vector> 
#include <queue> 
#include <deque> 
#include <stack> 
#include <set> 
#include <map> 
#include <complex> 
#include <bitset> 
#include <iomanip> 
#include <utility> 
 
using namespace std; 
 
typedef long long LL; 
typedef pair<int,int> pii; 
typedef complex<double> point; 
 
const int mod = 1000000007; 
 
int f[200000]; 
 
int POW (int base, int p){ 
  int ret = 1, cur = base; 
  while (p){ 
    if (p & 1) ret = (LL)ret * cur % mod; 
    p>>=1; 
    cur = (LL)cur * cur % mod; 
  } 
  return ret; 
} 
 
struct RandomGCD{ 
  int countTuples(int N, int K, int lo, int hi){ 
      memset(f, 0, sizeof(f));
    lo = (lo+K-1)/K, hi = hi/K;  
    if (lo > hi) 
      return 0; 
    for (int i=100000; i>=1; i--){ 
      int L = (lo + i-1) / i; 
      int H = hi / i; 
      if (L <= H){ 
        f[i] = POW(H-L+1, N);  
        f[i]-= (H-L+1); 
        if (f[i] < 0) f[i]+= mod; 
        for (int j=i*2; j<=100000; j+=i){ 
          f[i]-=f[j]; 
          if (f[i]<0) f[i]+= mod; 
        } 
      } 
    } 
    if (lo == 1) 
      f[1] = (f[1] + 1) % mod; 
    return f[1]; 
  }   
};
 
int main() {
    RandomGCD test;
    int N, K, L, R;
    while (cin >> N >> K >> L >> R) {
        cout << test.countTuples(N, K, L, R) << endl;
    }
    return 0;
}

 

 

平方排列

Description

 给你一个n，问能否将1到n这n个整数进行排列，使得这个排列中任意两个相邻的数字和都是平方数。如果能，输出这个排列（如果存在多个，输出字典序最小的），否则输出-1。

Input

 输入一个整数n (1 <= n <= 15)

Output

 如果存在这样的排列（如果存在多个，输出字典序最小的），输出n个以空格隔开的整数表示这个排列，否则输出-1。

Examples

Input

1

Output

1

 

正确解法：

这题想一想就知道，只有1和15.

但我们还是要用dfs，我还是不熟啊，变量有点多，有点复杂。

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<map>
#include<algorithm>
#include<cmath>
using namespace std;
int n,a[20], book[20], flag = 0;
void dfs(int k)
{
    if (k == n + 1)
    {
        flag = 1;
        for (int i = 1; i < n; i++)
            cout << a[i] << " ";
        cout << a[n] << endl;
        return ;
    }
    for (int i = 1; i <= n; i++)
    {
        int tmp = (int)sqrt(i + a[k - 1]);
        if (k>1&&i + a[k - 1] != tmp * tmp)
            continue;
        if (book[i] == 0&&flag==0)
        {
            book[i] = 1;
            a[k] = i;
            dfs(k + 1);
            book[i] = 0;
        }
    }
}
int main()
{
    flag = 0;
    cin >> n;
    dfs(1);
    if (flag == 0)    cout << -1 << endl;
    return 0;
}

除了第一个数，保证后面的数都与前面的数形成平方数。

最后找到n个输出就好了。

 

四色图

Description

 Perfectxx给LZH出了一道题，要LZH构造出一个尽可能大的四色图。所谓的四色图指的是由n个点m条边组成的无向图。其中，每个点要么是红色，要么是蓝色，每条边要么是黑色，要么是白色。

黑边能连接两个红点，或是一个红点与一个蓝点。而白边只能连接红点与蓝点。

LZH构造出了一个图，但是委托给Murphyc,让他去打印的时候，Murphyc用了黑白打印机。现在分不清楚顶点的颜色是红还是蓝。

现在你需要帮Perfectxx检查一下，LZH构造出的图有没有可能是四色图。

Input

第一行输入n和m，表示点的数量和边的数量 (1<=n,m<=2e5)

接下来的m行，每行三个输入 w u v 表示图中有一条从u到v的无向边，w=1时表示

这条边是黑边，w=0是表示这条边是白边。

Output

仅输出一行字符串，其中”Maybe”表示原图有可能是四色图,”Impossible”表示原图一定不是四色图。（输出中没有引号）

Examples

Input

4 4
0 1 2
0 2 3
0 3 4
0 4 1
3 3
0 1 2
0 2 3
0 3 1

Output

Maybe
Impossible

 

正确解法：

#include<bits/stdc++.h>
using namespace std;
const int N=500000;
int ins[N],dfn[N],low[N],cnt,sta[N];
int top,v,u;
int Next[N],head[N],to[N];
int tot;
int scc[N];
int scccnt;
void make_list(int u,int v){
    Next[++tot]=head[u],head[u]=tot,to[tot]=v;
}
void tarjan(int x){
    ins[x]=dfn[x]=low[x]=++cnt,sta[top++]=x;
    for(int p=head[x],v=to[p];p;p=Next[p],v=to[p])
        if(!dfn[v])tarjan(v),low[x]=min(low[x],low[v]);
        else if(ins[v])low[x]=min(low[x],dfn[v]);
    if(low[x]==dfn[x]){
        scc[x]=++scccnt,ins[x]=0;
        while((u=sta[--top])!=x)ins[u]=0,scc[u]=scccnt;
    }
}
int main(){
    int n,m,w,u,v;
    freopen("data5.in","r",stdin);
    freopen("data5.out","w",stdout);    
    scanf("%d%d",&n,&m); 
    for(int i=1;i<=m;i++){
        scanf("%d%d%d",&w,&u,&v);
        if(!w){
            make_list(u,v+n);
            make_list(v,u+n);
            make_list(u+n,v);
            make_list(v+n,u);
        }
        else{
            make_list(u+n,v);
            make_list(v+n,u);
        }
    }
    
    for(int i=1;i<=2*n;i++){
        if(!dfn[i])tarjan(i);
    }
    bool ok=1;
    for(int i=1;i<=n;i++){
        ok&=(scc[i]!=scc[i+n]);
    }
    if(ok)puts("Maybe");
    else puts("Impossible");
    return 0; 
} 

 

最大化

Description

 给你n个整数，请重新排列这些整数，使得式子的值最大，其中表示第i个整数。请输出S的最大值。

Input

第一行一个整数n(2 <= n <= 100000)，表示数字的个数；

第二行为n个整数 (1 <= ai <= 1000000000)

Output

输出一个整数，表示S的最大值。

Examples

Input

2
2 1

Output

1

 

正确解法：

S_max = (-1)^2 * (2 – 1) = 1

简单模拟一下，找到奇数和偶数的不同

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<map>
#include<algorithm>
#include<cmath>
using namespace std;
int n;
long long a[100100],sum=0;
int main()
{
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    sort(a + 1, a + n + 1);
    if (n % 2 == 0)
    {
        for (int i = n / 2 + 1; i <= n; i++)
            sum += 2*a[i];
        for (int i = 1; i <= n / 2; i++)
            sum -= 2*a[i];
        sum = sum - a[n / 2 + 1] +a[n / 2];
    }
    else
    {
        for (int i = n / 2 + 2; i <= n; i++)
            sum += 2*a[i];
        for (int i = 1; i <= n / 2; i++)
            sum -= 2*a[i];
        sum = sum - a[n / 2 + 1] - a[n / 2 - 2];
    }
    cout << sum << endl;
    return 0;
}

 

调整队列

Description

这天小g遇到了一个队列，小g觉得队列乱糟糟的不好看。于是小g希望将队列调整成为一个等差数列(差可为0)。但是小g对每个数都最多调整一次，每次可以对这个数加一、减一。请你帮助小g解决这个问题，如果能调整出等差队列，输出需要调整的数的最小数量，否则输出-1。

Input

第一行一个整数n(2 <= n <= 100000)，表示数列中数的个数；

第二行为n个整数pi (1 <= pi <= 1e9)。

Output

输出一个整数，表示操作数量的最小值。如果不存在则输出-1。

Examples

Input

4
24 21 14 10
2
500 500
3
14 5 1
5
1 3 6 9 12

Output

3
0
-1
1

正确解法：

暴力搜索qaq，不够熟悉，再见！

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<map>
#include<algorithm>
#include<cmath>
using namespace std; 
int n, a[100100],ans=-1;
void dfs(int k, int c, int d)
{
    if (k >= n + 1)
    {
        if (ans == -1)
            ans = c;
        else ans = min(ans,c);
        return;
    }
    for (int i = -1; i <= 1; i++)
    {
        if (a[k] + i - a[k - 1] == d)
        {
            a[k] += i;
            dfs(k + 1, c + abs(i), d);
            a[k] -= i;
        }
    }
}
int main()
{
    while (cin >> n)
    {
        ans = -1;
        for (int i = 1; i <= n; i++)
            cin >> a[i];
        for (int i = -1; i <= 1; i++)
        {
            a[1] += i;
            for (int j = -1; j <= 1; j++)
            {
                a[2] += j;
                dfs(3, abs(i) + abs(j), a[2] - a[1]);
                a[2] -= j;
            }
            a[1] -= i;
        }
        cout << ans << endl;
    }
    return 0;
}