中南大学oj:1352: New Sorting Algorithm

http://acm.csu.edu.cn/OnlineJudge/problem.php?id=1352

题意：就是要将7 1 5 2这样的序列变成1  2  5  7最少需要多少步？给出变的规律，每次把最前面的那个数移动到比它次小的数的后面，要是它后面没有比它次小的数，就移动到最后，问最少需要多少步？

For example, we will use 7 steps to sort the sequence 7 1 5 2:
    7 1 5 2 --> 1 5 7 2 --> 5 7 2 1 --> 7 2 5 1 --> 2 5 7 1 --> 5 7 1 2 --> 7 1 2 5 --> 1 2 5 7

思路：这个题目给出的数据量很大，所以一步步模拟肯定超时。那么就只能是看各种数字移动到它最终位置是否存在一定规律......经过思考，发现好像没有什么规律....于是这道题目我就放弃了.....然后我的一个队友说，一个数移动到它次小的数后面，那么就可以把这两个数合并成一个数，然后再找再合并.....这样时间复杂度会减少很多。的确是这样的，合并完之后，我们只需要用个并查集来统计有多少个数合并在一起了，然后每次移动的时候，把这些数加上即可.......只是，这样还有一个问题，如何找到比它次小的数？如果次小的数已经被合并了呢？......暴力去查找，明显耗时会很大，可能会超时，那么可以把数据进行离散化，由于所以数字都是独一无二的，那么在找次小的数的时候，我们只需要find(x-1)即可........

#include<iostream> 

#include<cstdio> 

#include<queue> 

#include<cstring> 

#include<algorithm> 

using namespace std; 

#define inf 100005 

typedef long long ss; 

ss father[inf],rank[inf]; 

ss a[inf],b[inf],n; 

queue<ss>q; 

queue<ss>q1; 

ss erfen(ss sum) 

{ 

    ss ll=0,rr=n-1; 

    while(ll<=rr) 

    { 

        ss mid=(ll+rr)/2; 

        if(b[mid]>sum) 

        rr=mid-1; 

        else    ll=mid+1; 

    } 

    return rr; 

} 

ss find(ss x) 

{ 

    ss i=x,root; 

    while(x!=father[x]) 

    x=father[x]; 

    root=x; 

    x=i; 

    while(x!=father[x]) 

    { 

        i=father[x]; 

        father[x]=root; 

        rank[root]+=rank[x]; 

        rank[x]=0; 

        x=i; 

    } 

    return root; 

} 

  

void liantong(ss x,ss y) 

{ 

    father[x]=y; 

    rank[y]+=rank[x]; 

    rank[x]=0; 

} 

int main() 

{ 

    ss text; 

    scanf("%lld",&text); 

    while(text--) 

    { 

        scanf("%lld",&n); 

        while(!q.empty()) 

        q.pop(); 

  

        while(!q1.empty()) 

        q1.pop(); 

        for(ss i=0;i<n;i++) 

        { 

            scanf("%lld",&a[i]); 

            b[i]=a[i]; 

            father[i]=i; 

            rank[i]=1; 

        } 

        sort(b,b+n); 

        //int ll=1,rr=n-1; 

        for(ss i=0;i<n;i++) 

        { 

            a[i]=erfen(a[i]); 

        } 

  

        for(ss i=0;i<n;i++) 

        { 

            q.push(a[i]); 

        } 

        ss ans=0; 

        while(!q.empty()) 

        { 

            ss x=q.front(); 

            q.pop(); 

            if(!q.empty()) 

            { 

                if(x==0) 

                { 

                    ss flg=0; 

                    ss tmp=x; 

                    while(!q.empty()) 

                    { 

                        ss y=q.front(); 

                        if(tmp<y) 

                        tmp=y; 

                        else flg=1; 

                        q.pop(); 

                        q1.push(y); 

                    } 

                    if(flg==1) 

                    { 

                        while(!q1.empty()) 

                        { 

                            ss y=q1.front(); 

                            q1.pop(); 

                            q.push(y); 

                        } 

                        q.push(x); 

                        ans+=rank[x]; 

                    } 

                    else break; 

                } 

                else

                { 

                    ans+=rank[x]; 

                    ss y=find(x-1); 

                    if(x!=y) 

                    { 

                        liantong(x,y); 

                    } 

                } 

            } 

        } 

        printf("%lld\n",ans); 

    } 

    return 0; 

}