中南大学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;
}