HihoCoder - 1781： Another Bubble Sort （冒泡排序&逆序对）

Sample Input

3
9
8 7 5 1 9 2 6 4 3
1 2 3 4 5 6 7 8 9
9
8 7 5 1 9 2 6 4 3
1 2 5 4 3 6 7 8 9
9
8 7 5 1 9 2 6 4 3
1 2 5 6 4 3 7 8 9

Sample Output

Case #1: 6
Case #2: 4
Case #3: -1

Prof.Q is a sophisticated professor who has insights into quadrillions of sorting algorithms, especially into bubble sort. Bubble sort is a simple algorithm that repeatedly steps through the array to be sorted, compares each pair of adjacent elements and swaps them if they are in the wrong order. In brief, bubble sort executes the following iteration over and over again until the array is sorted.

This is your first day becoming a student of Prof.Q, so he gives you two arrays A[1..N] and B[1..N] of length N
as a placement test. Your task is to check whether it is possible to
execute the aforementioned iteration several times on the array A and then transform it into the array B. Furthermore, determine the minimum times of iteration to achieve it if it is possible.

Input

The first line contains one integer T, indicating the number of test cases.

The following lines describe all the test cases. For each test case:

The first line contains one integer N.

The second line contains N integers A[1], A[2], · · · , A[N].

The third line contains N integers B[1], B[2], · · · , B[N].

1 ≤ T ≤ 1000, 1 ≤ N ≤ 10⁵ , 1 ≤ a_i ≤ 10⁹ (i = 1, 2, · · · , N).

It is guaranteed that the sum of N in all the test cases does not exceed 10⁶.

Output

For each test case, print "Case #x: y" (without quotes) in one line, indicating that this is the x-th test case and the minimum number of iterations for this test case is y if it is possible, print y as −1 otherwise.

题意：冒泡排序，两个for语句，第一个表示进行了几轮，第二个表示从左往右遍历，如果左边的大于右边的，则交换。现在给定A数组，B数组。  问A数组是否可以根据上述的规则进行K轮排序得到B， 如果可以，求出K，否则输出-1；

思路：我们不难根据位置的变化得到K； 然后我们可以需要求出A数组进行K轮排序后的数组。  这里根据逆序对+二分来求得。

因为每一轮排序下来，新的逆序对rev和上一轮的关系是：rev[i]=max(pre[i+1],0)；所以我们得到K轮后的结果，和B对比即可。

（注意这个数组的大小是1e9，我们需要离散化，即根据大小为第一关键字，位置为第二关键字排序。

#include<bits/stdc++.h>
#define ll long long
#define rep(i,a,b) for(int i=a;i<=b;i++)
using namespace std;
const int maxn=;
int a[maxn],rev[maxn],b[maxn],ans[maxn],pos[maxn],sum[maxn],N;
void add(int x,int v){ for(;x<=N;x+=(-x)&x) sum[x]+=v; }
int query(int x){int res=; for(;x;x-=(-x)&x) res+=sum[x]; return res;}
struct in{int x,pos; }s[maxn];
bool cmp(in w,in v ){ return w.x==v.x?w.pos<v.pos:w.x<v.x;}
void fcy(int f[]){
    rep(i,,N) s[i].x=f[i],s[i].pos=i; sort(s+,s+N+,cmp);
    rep(i,,N) f[s[i].pos]=i;
}
int main()
{
    int T,C=,K;
    scanf("%d",&T);
    while(T--){
        scanf("%d",&N); K=;
        rep(i,,N) scanf("%d",&a[i]);
        rep(i,,N) scanf("%d",&b[i]);
        fcy(a); fcy(b); //离散化
        rep(i,,N) pos[a[i]]=i;
        rep(i,,N) K=max(K,pos[b[i]]-i); //求K
        rep(i,,N) rev[i]=sum[i]=;
        rep(i,,N) {
           rev[i]=i--query(a[i]);
           add(a[i],);
        }//求A数组的逆序对
        rep(i,,N) rev[i]=max(,i+K>N?:rev[i+K]-K);
        rep(i,,N) sum[i]=;
        rep(i,,N) add(i,);
        for(int i=N;i>=;i--){
            int L=,R=N,res;
            while(L<=R){
                int Mid=(L+R)>>;
                if(query(Mid)>=i-rev[i]) res=Mid,R=Mid-;
                else L=Mid+;
            } ans[i]=res; add(res,-);
        }//二分定位答案
        rep(i,,N) if(ans[i]!=b[i]) {K=-; break;}
        printf("Case #%d: %d\n",++C,K);
    }
    return ;
}