hihoCoder挑戰賽34 B題（快速求第k輪冒泡排序的結果）

官方題解：https://media.hihocoder.com/contests/challenge34/tutorials-previewed.pdf

題目鏈接：http://hihocoder.com/problemset/problem/1781

題意問對於給定序列A，是否存在一個整數k, 使得A冒泡k輪后變成序列B.

這題一種做法是像官方題解一樣寫個計算區間最值的數據結構。

而我是另一種做法，通過的逆序數 來判斷A怎樣能變化到B。

例子

首先我舉一個例子：

對於序列  A      

8 7 5 1 9 2 6 4 3

其每個位置的逆序數是：

0 1 2 3 0 4 3 5 6       （*）

接着對A冒泡一輪，得到：

7 5 1 8 2 6 4 3 9

這時每個位置的逆序數是：

0 1 2 0 3 2 4 5 0      （**）

那么序列（*）和序列（**） 直接有啥聯系呢？

（**）=（*）每個數減-1，並向左平移一格 ，且最多減到0.

證明

現在來證明，每冒泡一輪 所有位置的逆序數-1，並向左移一格。

引理1：對於每輪冒泡排序，若一個位置的前面存在比他大的數，  則他一定會他前面的某個比他大的數進行有且僅有一次交換

這個引理大家自已腦補一下，應該很容易理解是對的。

引理2：若一個位置的前面存在比他大的數，則個位置的逆序數大於0

這個廢話，我就不解釋了。

證：因為任意一個逆序大於1位置，都與比他大的數交換一次，交換后首先逆序數必然減一，其次，交換后為位置肯定前移1格。 故結論成立。

 

解題思路

有了這個規律，顯然我可以直接O(n)求出任意一輪A的逆序數 與B比較。

再利用【逆序數和】每輪的都會遞減的單調性。就可以用二分比較逆序數和的方式，在O(n logn)時間定位b.

或者做一個O(n)預處理，算出n-1輪中，每輪的逆序數和，這樣可以把查詢的時間復雜度降低至O(n)

當然因為還要對數據進行O(n logn)離散化和求逆序數的原因，所以無論你寫哪種最終復雜度都是O(n logn)。

#include<stdio.h>
#include<vector>
#include<algorithm>
#include<string.h>
#include<stack>
#include<math.h>
using namespace std;
#define lowbit(x) (x&(-x))
int a[100005],b[100004];
int s1[200005],s2[100005];
int c[200005];
int N=200005;
int cot[200005];
int getsum(int x)
{
    int sum=0;
    while(x)
    {
        sum+=c[x];
        x-=lowbit(x);
    }
    return sum;
}
void add(int x)
{
    while(x<=N)
    {
        c[x]++;
        x+=lowbit(x);
    }
}
vector<int>que;
int getid(int x)
{
    return lower_bound(que.begin(),que.end(),x)-que.begin()+1;
}
void cal(int n,int a[],int ans[])
{
    int i;
    memset(c,0,sizeof(c));
    for(i=1; i<=n; i++)
    {
        ans[i]=(i-1)-getsum(a[i]);
        add(a[i]);
    }
}
int main()
{
    int i,j,t,n,x,y,k,op,q;
    long long m;
   // freopen("1.in","r",stdin);
    //freopen("2.out","w",stdout);
    scanf("%d",&t);
    for(int cas=1; cas<=t; cas++)
    {
        scanf("%d",&n);
        memset(s1,0,sizeof(s1));
        memset(cot,0,sizeof(cot));
        que.clear();
        for(i=1; i<=n; i++)
        {
            scanf("%d",&a[i]);
            que.push_back(a[i]);
        }
        for(i=1; i<=n; i++)
        {
            scanf("%d",&b[i]);
            que.push_back(b[i]);
        }
        sort(que.begin(),que.end());
        m=unique(que.begin(),que.end())-que.begin();
        que.resize(m);
        int ans=-1;
        for(i=1; i<=n; i++)
        {
            a[i]=getid(a[i]);
            b[i]=getid(b[i]);
        }
        cal(n,a,s1);
        cal(n,b,s2);
        long long sum=0;
        k=0;
        for(i=1; i<=n; i++)
        {
            cot[s1[i]]++;
            k=max(s1[i],k);
            sum+=s2[i];
            printf("%d ",s1[i]);
        }
        m=0;
        for(i=k+1; i>0; i--)
        {
            m=m+cot[i];
            sum-=m;
            if(sum<=0)
            {
                break;
            }
        }
        if(sum==0)
        {
            i--;
            for(j=1; j<=n; j++)
            {
                if(max(s1[j+i]-i,0)!=s2[j])
                {
                    break;
                }
            }
            if(j>n)
            {
                sort(a+1,a+n+1);
                sort(b+1,b+n+1);
                for(j=1; j<=n; j++)
                {
                    if(a[j]!=b[j])
                    {
                        break;
                    }
                }
                if(j>n)
                {
                    ans=i;
                }
            }
        }
        printf("Case #%d: %d\n",cas,ans);
    }
    return 0;

}