[SCOI2011]棘手的操作

题目描述

有N个节点，标号从1到N，这N个节点一开始相互不连通。第i个节点的初始权值为a[i]，接下来有如下一些操作：

• U x y: 加一条边，连接第x个节点和第y个节点
• A1 x v: 将第x个节点的权值增加v
• A2 x v: 将第x个节点所在的连通块的所有节点的权值都增加v
• A3 v: 将所有节点的权值都增加v
• F1 x: 输出第x个节点当前的权值
• F2 x: 输出第x个节点所在的连通块中，权值最大的节点的权值
• F3: 输出所有节点中，权值最大的节点的权值

输入格式

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

输出格式

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

 

 

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

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

首先，离线询问，用并查集维护连通性，并且预处理出每个数在线段树中的位置

然后，线段树常规操作，再次用并查集维护连通性，所在块=>及所在区

#include<bits/stdc++.h>
#define re return
#define ll long long
#define lson rt<<1
#define rson rt<<1|1
#define R register 
#define inc(i,l,r) for(int i=l;i<=r;++i)
const int maxn=300005,maxq=300005,inf=2147483647;
using namespace std;
char buf[1<<21],*p1,*p2;
template<typename T>inline void rd(T&x)
{
    char c;bool f=0;
    while((c=getchar())<'0'||c>'9')if(c=='-')f=1;
    x=c^48;
    while((c=getchar())>='0'&&c<='9')x=x*10+(c^48);
    if(f)x=-x;
}

int ans,n,q,rt,tot,opt[maxq],a1[maxq],a2[maxq],a[maxn];
int pos[maxn],fa[maxn],val[maxn],lazy[maxn<<2],t[maxn<<2];;
struct node
{
    int r,rf;
}num[maxn];

inline void build(int rt,int l,int r)
{
    if(l==r)
    {
        t[rt]=val[l];
        re ;
    }
    int mid=(l+r)>>1;
    build(lson,l,mid);
    build(rson,mid+1,r);
    t[rt]=max(t[lson],t[rson]);
}

inline void pushdown(int rt)
{
    t[lson]+=lazy[rt];
    lazy[lson]+=lazy[rt];
    t[rson]+=lazy[rt];
    lazy[rson]+=lazy[rt];
    lazy[rt]=0;
}


inline void add(int rt,int l,int r,int x,int y,int z)
{
    if(x<=l&&r<=y)
    {
        lazy[rt]+=z;
        t[rt]+=z;
        re;
    }
    if(lazy[rt])
        pushdown(rt);
    int mid=(l+r)>>1;
    if(x<=mid)add(lson,l,mid,x,y,z);
    if(y>mid) add(rson,mid+1,r,x,y,z);
    t[rt]=max(t[lson],t[rson]);
}

inline void query(int rt,int l,int r,int x,int y)
{
    if(x<=l&&r<=y)
    {
        ans=ans>t[rt]?ans:t[rt];
        re ;
    }
    
    if(lazy[rt])
        pushdown(rt);
    int mid=(l+r)>>1;
    if(x<=mid)query(lson,l,mid,x,y);
    if(y>mid) query(rson,mid+1,r,x,y);
}

inline int find(int x)
{
    re x==fa[x]?x:fa[x]=find(fa[x]);
}
int main()
{
    
    rd(n);
    inc(i,1,n)
    {
        rd(a[i]);
        fa[i]=num[i].r=i;
    }
    
    rd(q);
    char ord[3];
    inc(i,1,q)
    {
        scanf("%s",ord);
        if(ord[0]=='U')
        {
            opt[i]=1;
            rd(a1[i]),rd(a2[i]);
            //第一遍并查集，排好序
            int f1=find(a1[i]),f2=find(a2[i]);
            if(f1==f2) continue;
            num[num[f1].r].rf=f2;
            num[f1].r=num[f2].r;
            fa[f2]=f1;
        }
        else if(ord[0]=='A')
        {
            if(ord[1]=='1')
            {
                opt[i]=2;
                rd(a1[i]),rd(a2[i]);
            }
            else if(ord[1]=='2')
            {
                opt[i]=3;
                rd(a1[i]),rd(a2[i]);
            }
            else 
            {
                opt[i]=4;
                rd(a1[i]);
            }
            
        }
        else 
        {
            if(ord[1]=='1')
            {
                opt[i]=5;
                rd(a1[i]);
            }
            else if(ord[1]=='2')
            {
                opt[i]=6;
                rd(a1[i]);
            }
            else opt[i]=7;
        }
    }
    
    int cnt=0;
    inc(i,1,n)
    if(!pos[i])
    {
        int f1=find(i);
        pos[f1]=++cnt;
        val[cnt]=a[f1];
        while(num[f1].rf)
        {
            f1=num[f1].rf;
            pos[f1]=++cnt;
            val[cnt]=a[f1];
        }
    }
    
    build(1,1,n);
    
    inc(i,1,n)
    fa[i]=num[i].r=i;
    
    int f1,f2;
    inc(i,1,q)
    {
        if(i==95)
        i=95;
        switch(opt[i])
        {
            case 1://第二遍并查集，维护区间
　　
                    f1=find(fa[a1[i]]);
                    f2=find(fa[a2[i]]);
                    fa[f2]=f1;
                    num[f1].r=num[f2].r;
                    break;
            case 2:
                     add(1,1,n,pos[a1[i]],pos[a1[i]],a2[i]);
                    break;
            case 3:
                    f1=find(fa[a1[i]]);
                    add(1,1,n,pos[f1],pos[num[f1].r],a2[i]);
                    break;
            case 4:
                    lazy[1]+=a1[i];
                    t[1]+=a1[i];
                    break;
            case 5:
                    ans=-inf;
                    query(1,1,n,pos[a1[i]],pos[a1[i]]);
                    printf("%d\n",ans);
                    break;
            case 6:
                    ans=-inf;
                    f1=find(fa[a1[i]]);
                    query(1,1,n,pos[f1],pos[num[f1].r]);
                    printf("%d\n",ans);
                    break;
            case 7:
                    printf("%d\n",t[1]);
                    break;
        }
    } 
    re 0;
}