洛谷P3273 [SCOI2011]棘手的操作

题目描述

有N个节点，标号从1到N，这N个节点一开始相互不连通。第i个节点的初始权值为a[i]，接下来有如下一些操作：U x y: 加一条边，连接第x个节点和第y个节点A1 x v: 将第x个节点的权值增加vA2 x v: 将第x个节点所在的连通块的所有节点的权值都增加vA3 v: 将所有节点的权值都增加vF1 x: 输出第x个节点当前的权值F2 x: 输出第x个节点所在的连通块中，权值最大的节点的权值F3: 输出所有节点中，权值最大的节点的权值

输入输出格式

输入格式：

输入的第一行是一个整数N，代表节点个数。接下来一行输入N个整数，a[1], a[2], ..., a[N]，代表N个节点的初始权值。再下一行输入一个整数Q，代表接下来的操作数。最后输入Q行，每行的格式如题目描述所示。

输出格式：

对于操作F1, F2, F3，输出对应的结果，每个结果占一行。

输入输出样例

输入样例#1： 复制

3
0 0 0
8
A1 3 -20
A1 2 20
U 1 3
A2 1 10
F1 3
F2 3
A3 -10
F3

输出样例#1： 复制

-10
10
10

说明

对于30%的数据，保证 N<=100，Q<=10000

对于80%的数据，保证 N<=100000，Q<=100000

对于100%的数据，保证 N<=300000，Q<=300000

对于所有的数据，保证输入合法，并且 -1000<=v, a[1], a[2], ..., a[N]<=1000

开两个可并堆堆

分别维护联通快最大值和所有的最大值

U x y: 加一条边，连接第x个节点和第y个节点

直接合并

A1 x v: 将第x个节点的权值增加v

先删掉，再加上原来的权值加v

A2 x v: 将第x个节点所在的连通块的所有节点的权值都增加v

跟线段树一样打个标记

A3 v: 将所有节点的权值都增加v

直接用一个变量记录

F1 x: 输出第x个节点当前的权值

直接输出

F2 x: 输出第x个节点所在的连通块中，权值最大的节点的权值

找到父亲，输出

F3: 输出所有节点中，权值最大的节点的权值

输出维护最大值的那个堆的根节点

效率暂时rank1

 #include<cstdio>
 #include<cmath>
 #include<algorithm>
 #include<iostream>
 #include<queue>
 using namespace std;
 const int MAXN=;
 #define ls T[x].ch[0]
 #define rs T[x].ch[1]
 inline int read()
 {
     int a;
     cin>>a;
     return a;
 }
 int root,N,All;
 struct Priority
 {
     struct node
     {
         int fa,dis,val,ch[],mark;
     }T[MAXN];
     void Clear(int x){ls=rs=;T[x].fa=;}
     void Pushdown(int x)
     {
         if(ls) T[ls].val+=T[x].mark,T[ls].mark+=T[x].mark;
         if(rs) T[rs].val+=T[x].mark,T[rs].mark+=T[x].mark;
         T[x].mark=;
     }
     int Merge(int x,int y)
     {
         if(!x||!y)    return x+y;
         if( T[x].val < T[y].val)    swap(x,y);
         Pushdown(x);
         rs=Merge(rs,y);
         T[rs].fa=x;
         if(T[rs].dis>T[ls].dis) swap(ls,rs);
         T[x].dis=T[rs].dis+;
         return x;
     }
     int Delet(int x)
     {
         Pushdown(x);
         int q=T[x].fa,p=Merge(ls,rs);
         T[p].fa=q;
         T[q].ch[ T[q].ch[] == x] = p;
         while(q)
         {
             if(T[ T[q].ch[] ].dis < T[ T[q].ch[] ].dis)   swap( T[q].ch[] , T[q].ch[] );
             if(T[ T[q].ch[] ].dis+ == T[q].dis)   return root;
             T[q].dis=T[ T[q].ch[] ].dis+;
             p=q;q=T[q].fa;
         }
         return p;
     }
     int Find(int x)
     {
         while(T[x].fa) x=T[x].fa;
         return x;
     }
     int Sum(int x)
     {
         int ans=;
         while(x=T[x].fa)  ans+=T[x].mark;
         return ans;
     }
     int AddPoint(int x,int v)
     {
         int fx=Find(x);
         if(fx==x)
         {
             if(ls+rs==)
                 {T[x].val+=v;return x;}
             else
                 if(ls)  fx=ls;
                 else     fx=rs;
         }
         Delet(x);
         T[x].val+=v+Sum(x);
         Clear(x);
         return Merge(Find(fx),x);
     }
     int Build()
     {
         queue<int>q;
         for(int i=;i<=N;i++)
             q.push(i);
         while(q.size()>)
         {
             int x=q.front();q.pop();
             int y=q.front();q.pop();
             int z=Merge(x,y);
             q.push(z);
         }
         return q.front();
     }
 };
 Priority h1,h2;
 int main()
 {
     #ifdef WIN32
     freopen("a.in","r",stdin);
     freopen("b.out","w",stdout);
     #else
     #endif
     char opt[];
     N=read();
     h1.T[].dis=h2.T[].dis=-;
     for(int i=;i<=N;i++)
         h2.T[i].val=h1.T[i].val=read();
     root=h2.Build();
     int M=read();
     while(M--)
     {
         scanf("%s",opt+);
         if(opt[]=='U')
         {
             int x=read(),y=read();
             int fx=h1.Find(x),fy=h1.Find(y);
             if(fx!=fy)
             {
                    int tmp=h1.Merge(fx,fy);
                 if(tmp==fx) root=h2.Delet(fy);
                 else         root=h2.Delet(fx);//优化,根据大根堆的性质，以后的就没有用了
             }
         }
         else if(opt[]=='A')
         {
             if(opt[]=='')
             {
                 int x=read(),v=read();
                 root=h2.Delet(h1.Find(x));
                 int y=h1.AddPoint(x,v);
                 h2.T[y].val=h1.T[y].val;
                 h2.Clear(y);
                 root=h2.Merge(root,y);
             }
             else if(opt[]=='')
             {
                 int x=read(),v=read();
                 int fx=h1.Find(x);
                 root=h2.Delet(fx);
                 h1.T[fx].val+=v;
                 h1.T[fx].mark+=v;
                 h2.T[fx].val=h1.T[fx].val;
                 h2.Clear(fx);
                 root=h2.Merge(root,fx);
             }
             else if(opt[]=='')
             {
                 int v=read();
                 All+=v;
             }

         }
         else if(opt[]=='F')
         {
             if(opt[]=='')
             {
                 int x=read();
                 printf("%d\n",h1.T[x].val+h1.Sum(x)+All);
             }
             else if(opt[]=='')
             {
                 int x=read();
                 printf("%d\n",h1.T[h1.Find(x)].val+All);
             }
             else if(opt[]=='')
                 printf("%d\n",h2.T[root].val+All);
         }
     }
 }