[SCOI2011]棘手的操作(可并堆/并查集/线段树)

[SCOI2011]棘手的操作(可并堆/并查集/线段树)

我懒死了

过于棘手

但这题真的很水的说

毕竟写啥都能过

常见思路：

①：由于不强制在线，所以重新编号之后线段树维护

②：用各种可以高速合并的数据结构，比如可并堆，可并平衡树啥的

讲一种无脑算法：

对于$F1$，并查集乱搞

对于$F2$，用可并堆维护连通块里的值，并维护对应的时间，如果堆顶访问到旧的值直接抛出

对于$F3$，用全局堆维护每个连通块的最大值的集合并维护对应的时间，如果堆顶访问到旧的值直接抛出

$A1$：单点修改时在所在可并堆里插入一个新的，维护修改时间，同时在全局堆里插入一个新的该可并堆的最大值

$A2$：在堆上打tag，在全局堆中插入新的最大值

$A3$：维护一个全局变量

$U$:略

好气啊将近二百行可并堆写的一点问题没有结果十多行并查集出了三处锅...

#include<cstdio>
#include<queue>
#include<algorithm>
using std::max;
using std::priority_queue;
using std::swap;
const int N=300011;
int n,v[N],del[N],Del;
char op[32];

int lta[N],ltb[N];
struct shino
{
    int id,v,t;
    shino(){}
    shino(int a,int b,int c){id=a,v=b,t=c;}
    bool friend operator < (shino x,shino y){return x.v<y.v;}
}g;
struct merheap
{
    int dis[N<<1],tag[N<<1],son[N<<1][2],fa[N<<1],kr,yop[N<<1],rt[N<<1];
    shino el[N<<1];
    int find(int x)
    {
        if(fa[x]==x) return x;
        else return fa[x]=find(fa[x]);
    }
    void fuckdown(int x)
    {
        if(tag[x])
        {
            int k=son[x][0];
            if(k){el[k].v+=tag[x];tag[k]+=tag[x];}
            k=son[x][1];
            if(k){el[k].v+=tag[x];tag[k]+=tag[x];}
            tag[x]=0;
        }
    }
    int makenew(shino sn)
    {
        kr++;
        el[kr]=sn;
        fa[kr]=kr;
        return kr;
    }
    int merge(int x,int y)
    {
        if(!x) return y;
        if(!y) return x;
        fuckdown(x);
        fuckdown(y);
        if(el[x]<el[y]) swap(x,y);
        son[x][1]=merge(son[x][1],y);
        fa[son[x][1]]=x;
        if(dis[son[x][0]]<dis[son[x][1]]) swap(son[x][0],son[x][1]);
        dis[x]=dis[son[x][1]]+1;
        return x;
    }
    void push(int x,shino ei)
    {
        int tmp=makenew(ei);
        int xx=find(x);
        rt[x]=merge(xx,tmp);
    }
    void pop(int x)
    {
        int xx=find(x);
        fuckdown(xx);
        int tmp=merge(son[xx][0],son[xx][1]);
        fa[xx]=tmp;
        if(son[xx][0]) fa[son[xx][0]]=tmp;
        if(son[xx][1]) fa[son[xx][1]]=tmp;
        rt[x]=tmp;
    }
    shino top(int x)
    {
        x=find(x);
        return el[x];
    }
    void update(int x)
    {
        int xx=find(x);
        while(xx)
        {
            xx=find(xx);
            g=top(xx);
            if(g.t!=lta[g.id]) pop(xx);
            else break;
        }
    }
    void add(int x,int vi)
    {
        int xx=find(x);
        el[xx].v+=vi;
        tag[xx]+=vi;
    }
    void init()
    {
        for(int i=1;i<=n;i++)
        {
            makenew(shino(i,v[i],0));
            rt[i]=i;
        }
    }
}rk;
int fa[N];
bool isrt[N];
void domerge(int x,int y);
priority_queue<shino> q;
void find(int x)
{
    if(fa[x]!=fa[fa[x]]) find(fa[x]),v[x]+=del[fa[x]];
    fa[x]=fa[fa[x]];
}
void merge(int x,int y,int tt)
{
    find(x),find(y);
    int fx=fa[x],fy=fa[y];
    if(fx==fy) return;
    domerge(fx,fy);
    q.push(shino(fy,rk.top(fy).v,tt));
    ltb[fy]=tt;
    fa[fx]=fy;
    del[fx]-=del[fy];
    v[fx]+=del[fx];
    isrt[fx]=0;
}
void domerge(int x,int y)
{
    int xx=rk.find(x),yy=rk.find(y);
    int tmp=rk.merge(xx,yy);
    rk.fa[xx]=rk.fa[yy]=rk.rt[y]=tmp;
}
void fuckdate()
{
    while(!q.empty())
    {
        g=q.top();
        if(!isrt[g.id]||g.t!=ltb[g.id]) q.pop();
        else break;
    }
}

int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&v[i]),fa[i]=i,isrt[i]=1;
    int T;
    scanf("%d",&T);
    rk.init();
    for(int i=1;i<=n;i++) q.push(shino(i,v[i],0));
    int xin,yin,vin;
    for(int t=1;t<=T;t++)
    {
        scanf("%s",op);
        if(op[0]=='U')
        {
            scanf("%d%d",&xin,&yin);
            merge(xin,yin,t);
        }else if(op[0]=='A')
        {
            if(op[1]=='1')
            {
                scanf("%d%d",&xin,&vin);
                find(xin);
                v[xin]+=vin;
                rk.push(fa[xin],shino(xin,v[xin]+del[fa[xin]],t));
                lta[xin]=t;
                rk.update(fa[xin]);
                q.push(shino(fa[xin],rk.top(fa[xin]).v,t));
                ltb[fa[xin]]=t;
            }else if(op[1]=='2')
            {
                scanf("%d%d",&xin,&vin);
                find(xin);
                del[fa[xin]]+=vin;
                rk.add(fa[xin],vin);
                q.push(shino(fa[xin],rk.top(fa[xin]).v,t));
                ltb[fa[xin]]=t;
            }else
            {
                scanf("%d",&vin);
                Del+=vin;
            }
        }else if(op[0]=='F')
        {
            if(op[1]=='1')
            {
                scanf("%d",&xin);
                find(xin);
                printf("%d
",v[xin]+del[fa[xin]]+Del);
            }else if(op[1]=='2')
            {
                scanf("%d",&xin);
                find(xin);
                rk.update(fa[xin]);
                printf("%d
",rk.top(fa[xin]).v+Del);
            }else
            {
                fuckdate();
                g=q.top();
                printf("%d
",g.v+Del);
            }
        }
    }
    return 0;
}

题外话：你这题解也太水了吧

rkk：因为确实水死了啊...都快成板子了...