Codeforces Round #424 (Div. 2) E. Cards Sorting(线段树)

题目链接：Codeforces Round #424 (Div. 2) E. Cards Sorting

题意：

将n个数放进一个队列，每次检查队首，看看是不是队列中最小的数，如果是就扔掉，如果不是就放到队尾。

这样直到队列为空，为需要操作多少次。

题解：

考虑用两个指针模拟，最开始now指针指向第一个数，然后nxt指针指向下一个将要被删除的数。

然后我们要算出这里需要移动多少步，然后删掉这个数，一直重复操作，直到将全部的数删完。

nxt指针可以用set来维护，now指针可以用并查集来维护。

计算now指针到nxt指针需要移动多少步，可以用线段树或者splay来维护。

线段树版本：

#include<bits/stdc++.h>
#define RT(l,r) (l+r|l!=r)
#define F(i,a,b) for(int i=a;i<=b;++i)
using namespace std;

const int N=1e6+7;
int n,now,f[N],cnt,x,sum[N*2];
struct node
{
    int x,idx;
    bool operator <(const node &b)const{return x!=b.x?x<b.x:idx<b.idx;}
};
set<node>st;
set<node>::iterator it;

int find(int x){return f[x]!=x?f[x]=find(f[x]):x;}

int getnxt()
{
    int X=st.begin()->x;
    it=st.lower_bound({X,now});
    if(it==st.end()||it->x > X)
        it=st.lower_bound({X,1});
    int tmp=it->idx;
    st.erase(it);
    return tmp;
}

void update(int pos,int v,int l=1,int r=n)
{
    int rt=RT(l,r),m=l+r>>1;
    if(l==r){sum[rt]+=v;return;}
    if(pos<=m)update(pos,v,l,m);
    else update(pos,v,m+1,r);
    sum[rt]=sum[RT(l,m)]+sum[RT(m+1,r)];
}

int query(int L,int R,int l=1,int r=n)
{
    int rt=RT(l,r),m=l+r>>1,an=0;
    if(L<=l&&r<=R)return sum[rt];
    if(L<=m)an+=query(L,R,l,m);
    if(R>m)an+=query(L,R,m+1,r);
    return an;
}


int ask(int a,int b)
{
    if(a<=b)return query(a,b);
    else return query(a,n)+query(1,b);
}

int main()
{
    scanf("%d",&n);
    F(i,1,n)
    {
        scanf("%d",&x),f[i]=i;
        st.insert({x,i}),update(i,1);
    }
    now=1,cnt=1;
    long long ans=0;
    while(cnt<=n)
    {
        int nxt=getnxt();
        ans+=ask(now,nxt);
        if(nxt<n)f[nxt]=nxt+1;else f[nxt]=1;
        if(cnt<n)now=find(nxt);
        update(nxt,-1);
        cnt++;
    }
    printf("%lld
",ans);
    return 0;
}

splay版本：

#include<bits/stdc++.h>
#define F(i,a,b) for(int i=a;i<=b;++i)
using namespace std;
const int N=1e6+7;
int _t;
struct Splay_tree
{
    int root,q[N];
    int key[N],sz[N],f[N],ch[N][2],add[N];
    void init(){root=_t=0;}//初始化为一棵空树
    inline void nw(int &x,int val,int fa)
    {
        x=++_t,key[x]=val,f[x]=fa,sz[x]=1;
        ch[x][0]=ch[x][1]=0;
    }
    inline void pd(int x){}
    inline void up(int x){sz[x]=sz[ch[x][0]]+sz[ch[x][1]]+1;}
    void rotate(int x){
        int y=f[x],w=ch[y][1]==x;
        ch[y][w]=ch[x][w^1];
        if(ch[x][w^1])f[ch[x][w^1]]=y;
        if(f[y]){
            int z=f[y];
            if(ch[z][0]==y)ch[z][0]=x;
            if(ch[z][1]==y)ch[z][1]=x;
        }
        f[x]=f[y],ch[x][w^1]=y,f[y]=x,up(y);
    }

    void splay(int x,int w){
        int s=1,i=x,y;q[1]=x;
        while(f[i])q[++s]=i=f[i];
        while(s)pd(q[s--]);
        while(f[x]!=w){
            y=f[x];
            if(f[y]!=w){if((ch[f[y]][0]==y)^(ch[y][0]==x))rotate(x);else rotate(y);}
            rotate(x);
        }
        if(!w)root=x;
        up(x);
    }
    void build(int &x,int l,int r,int fa=0)//按照数组下标建树
    {
        if(l>r)return;
        int mid=l+r>>1;
        nw(x,mid,fa);
        build(ch[x][0],l,mid-1,x);
        build(ch[x][1],mid+1,r,x);
        up(x);
    }
    inline int find(int _key) //返回值为key的节点 若无返回0 若有将其转移到根处
    {
        if(!root)return 0;
        int x=root;
        for(pd(x);x&&key[x]!=_key;)x=ch[x][key[x]<_key];
        if(x)splay(x,0);
        return x;
    }
    inline void Delete(int r)//删除下标为r的节点
    {  
        splay(r,0);
        int pos=sz[ch[r][0]];
        splay(kth(pos),0);
        splay(kth(pos+2),root);
        ch[ch[root][1]][0]=0;  
        up(ch[root][1]),up(root);
    } 
    inline int kth(int k)//获得第k小
    {
        if(k>sz[root]||k<=0)return 0;
        int x=root,tmp;
        while(1)
        {
            pd(x),tmp=sz[ch[x][0]]+1;
            if(k==tmp)break;
            if(k<tmp)x=ch[x][0];else k-=tmp,x=ch[x][1];
        }
        return x;
    }
}spt;
//--------------------------------

int n,now,f[N],ed;
struct node
{
    int x,idx;
    bool operator <(const node &b)const{return x!=b.x?x<b.x:idx<b.idx;}
}a[N];
set<node>st;
set<node>::iterator it;
int find(int x){return f[x]!=x?f[x]=find(f[x]):x;}

int getkth(int x)
{
    int rt=spt.find(x);
    return spt.sz[spt.ch[rt][0]]+1;
}

int del()
{
    it=st.lower_bound({a[ed].x,now});
    if(it==st.end()||it->x > a[ed].x)
    {
        it=st.lower_bound({a[ed].x,1});
    }
    int tmp=it->idx;
    st.erase(it);
    return tmp;
}

int main()
{
    scanf("%d",&n);
    F(i,1,n)scanf("%d",&a[i].x),a[i].idx=i,f[i]=i,st.insert(a[i]);
    sort(a+1,a+1+n);
    spt.build(spt.root,1,n+2);
    now=1,ed=1;
    long long ans=0;
    while(ed<=n)
    {
        int cur=getkth(now+1),tp=del();
        int tmp=getkth(tp+1);
        if(tmp>=cur)ans+=tmp-cur+1;
        else ans+=spt.sz[spt.root]-cur+tmp-1;
        int rt=spt.find(tp+1);
        spt.Delete(rt);
        if(tp<n)f[tp]=tp+1;
        else f[tp]=1;
        if(ed<n)now=find(f[tp]);
        ed++;
    }
    printf("%lld
",ans);
    return 0;
}