BZOJ3192: [JLOI2013]删除物品(splay)

Description

 

箱子再分配问题需要解决如下问题：

 （1）一共有N个物品，堆成M堆。

 （2）所有物品都是一样的，但是它们有不同的优先级。

 （3）你只能够移动某堆中位于顶端的物品。

 （4）你可以把任意一堆中位于顶端的物品移动到其它某堆的顶端。若此物品是当前所有物品中优先级最高的，可以直接将之删除而不用移动。

 

（5）求出将所有物品删除所需的最小步数。删除操作不计入步数之中。

 （6）只是一个比较难解决的问题，这里你只需要解决一个比较简单的版本：

         不会有两个物品有着相同的优先级，且M=2

 

Input

第一行是包含两个整数N1,N2分别表示两堆物品的个数。

接下来有N1行整数按照从顶到底的顺序分别给出了第一堆物品中的优先级，数字越大，优先级越高。

再接下来的N2行按照同样的格式给出了第二堆物品的优先级。

 

Output

对于每个数据，请输出一个整数，即最小移动步数。

Sample Input

3 3
1
4
5
2
7
3

Sample Output

6

解题思路：

决策已经很明显了，找到最大的，把上面的压到另外一堆里。

考虑splay维护一下。

还要开long long.

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
#define lll tr[spc].ch[0]
#define rrr tr[spc].ch[1]
#define ls ch[0]
#define rs ch[1]
using std::swap;
const int N=1000000;
typedef long long lnt;
struct data{
    lnt Max_val;
    lnt Where_is_Max_Val;
    bool friend operator < (data x,data y)
    {
        return x.Max_val<y.Max_val;
    }
    lnt wp()
    {
        return Where_is_Max_Val;
    }
};
struct trnt{
    int ch[2];
    int fa;
    int lzt;
    lnt val;
    data mxs;
    lnt wgt;
}tr[N];
int siz;
int n1,n2;
int root1,root2;
int fst1,lst1;
int fst2,lst2;
lnt ans=0;
lnt num[N];
data max(data a,data b)
{
    if(a.Max_val<b.Max_val)
        return b;
    return a;
}
bool whc(int spc)
{
    return tr[tr[spc].fa].rs==spc;
}
void res(int spc)
{
    tr[spc].wgt=1;
    tr[spc].mxs=(data){tr[spc].val,spc};
    return ;
}
void pushup(int spc)
{
    res(spc);
    if(lll)
    {
        tr[spc].wgt+=tr[lll].wgt;
        tr[spc].mxs=max(tr[spc].mxs,tr[lll].mxs);
    }
    if(rrr)
    {
        tr[spc].wgt+=tr[rrr].wgt;
        tr[spc].mxs=max(tr[spc].mxs,tr[rrr].mxs);
    }
    return ;
}
void trr(int spc)
{
    if(!spc)
        return ;
    tr[spc].lzt^=1;
    swap(lll,rrr);
    return ;
}
void pushdown(int spc)
{
    if(tr[spc].lzt)
    {
        trr(lll);
        trr(rrr);
        tr[spc].lzt=0;
    }
    return ;
}
void recal(int spc)
{
    if(tr[spc].fa)
        recal(tr[spc].fa);
    pushdown(spc);
    return ;
}
void rotate(int spc)
{
    int f=tr[spc].fa;
    bool k=whc(spc);    
    tr[f].ch[k]=tr[spc].ch[!k];
    tr[spc].ch[!k]=f;
    tr[tr[f].fa].ch[whc(f)]=spc;
    tr[spc].fa=tr[f].fa;
    tr[f].fa=spc;
    tr[tr[f].ch[k]].fa=f;
    pushup(f);
    pushup(spc);
    return ;
}
int splay(int spc,int f)
{
    recal(spc);
    while(tr[spc].fa!=f)
    {
        int ft=tr[spc].fa;
        if(tr[ft].fa==f)
        {
            rotate(spc);
            break;
        }
        if(whc(spc)^whc(ft))
            rotate(spc);
        else
            rotate(ft);
        rotate(spc);
    }
    return spc;
}
void build(int &spc,int l,int r,int f)
{
    if(l>r)
        return ;
    spc=++siz;
    int mid=(l+r)>>1;
    tr[spc].fa=f;
    tr[spc].val=num[mid];
    res(spc);
    build(lll,l,mid-1,spc);
    build(rrr,mid+1,r,spc);
    pushup(spc);
    return ;
}
int fstfind(int spc)
{
    while(lll)
        spc=lll;
    return spc;
}
int lstfind(int spc)
{
    while(rrr)
        spc=rrr;
    return spc;
}
int maxmin(int spc)
{
    pushdown(spc);
    spc=lll;
    pushdown(spc);
    while(rrr)
    {
        spc=rrr;
        pushdown(spc);
    }
    return spc;
}
int minmax(int spc)
{
    pushdown(spc);
    spc=rrr;
    pushdown(spc);
    while(lll)
    {
        spc=lll;
        pushdown(spc);
    }
    return spc;
}
int lstmax(int spc)
{
    pushdown(spc);
    if(lll)
        return maxmin(spc);
    recal(spc);
    while(whc(spc)==0)
        spc=tr[spc].fa;
    return tr[spc].fa;
}
int main()
{
    scanf("%d%d",&n1,&n2);
    for(int i=1;i<=n1;i++)
        scanf("%lld",&num[n1-i+1]);
    build(root1,0,n1+1,0);
    fst1=fstfind(root1);
    lst1=lstfind(root1);
    for(int i=1;i<=n2;i++)
        scanf("%lld",&num[n2-i+1]);
    build(root2,0,n2+1,0);
    fst2=fstfind(root2);
    lst2=lstfind(root2);
    for(int i=1;i<=n1+n2;i++)
    {
        root1=splay(fst1,0);
        splay(lst1,root1);
        root2=splay(fst2,0);
        splay(lst2,root2);
        int spc1,spc2;
        spc1=tr[tr[root1].rs].ls;
        spc2=tr[tr[root2].rs].ls;
        if(tr[spc1].mxs<tr[spc2].mxs)
        {
            root2=splay(tr[spc2].mxs.wp(),0);
            splay(lst2,root2);
            int tmp=tr[tr[root2].rs].ls;
            tr[tr[root2].rs].ls=0;
            pushup(tr[root2].rs);
            pushup(root2);
            ans+=tr[tmp].wgt;
            trr(tmp);
            int temp=root2;
            root2=splay(maxmin(temp),0);
            splay(minmax(temp),root2);
            tr[tr[root2].rs].ls=0;
            pushup(tr[root2].rs);
            pushup(root2);
            root1=splay(lstmax(lst1),0);
            splay(lst1,root1);
            tr[tr[root1].rs].ls=tmp;
            tr[tmp].fa=tr[root1].rs;
            pushup(tr[root1].rs);
            pushup(root1);
        }else{
            root1=splay(tr[spc1].mxs.wp(),0);
            splay(lst1,root1);
            int tmp=tr[tr[root1].rs].ls;
            tr[tr[root1].rs].ls=0;
            pushup(tr[root1].rs);
            pushup(root1);
            ans+=tr[tmp].wgt;
            trr(tmp);
            int temp=root1;
            root1=splay(maxmin(temp),0);
            splay(minmax(temp),root1);
            tr[tr[root1].rs].ls=0;
            pushup(tr[root1].rs);
            pushup(root1);
            root2=splay(lstmax(lst2),0);
            splay(lst2,root2);
            tr[tr[root2].rs].ls=tmp;
            tr[tmp].fa=tr[root2].rs;
            pushup(tr[root2].rs);
            pushup(root2);
        }
    }
    printf("%lld\n",ans);
    return 0;
}