bzoj 2959 长跑（LCT+BCC+并查集）

 

【题目链接】

 

    http://www.lydsy.com/JudgeOnline/problem.php?id=2959

 

【题意】

 

    n个点，提供操作：连边，修改点权，查询自定义边的方向后起点a终点b能经过的最大点权和。

 

【思路】

 

    对于一个边的双连通分量，显然可以将权值全部获得。

    如果没有连边操作，我们只需要将一个bcc缩点后求得a->b路径上的点权和即可。

    加上连边后，使用并查集代表一个bcc，如果u,v之间不连通直接连边，如果已经连通则构成一个bcc，使用并查集将LCT的所有节点合并。

    注意缩点后以并查集的代表元为该点，Access上找父亲的时候应该用父亲的bcc代表元。

 

【代码】

 

#include<set>
#include<cmath>
#include<queue>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define FOR(a,b,c) for(int a=(b);a<=(c);a++)
using namespace std;

typedef long long ll;
const int N = 3e5+10;

ll read() {
    char c=getchar();
    ll f=1,x=0;
    while(!isdigit(c)) {
        if(c=='-') f=-1; c=getchar();
    }
    while(isdigit(c))
        x=x*10+c-'0',c=getchar();
    return x*f;
}

struct UFS {
    int p[N];
    int ifind(int x) {
        if(p[x]==0||x==p[x]) return p[x]=x;
        return p[x]=ifind(p[x]); 
    }
    void iunion(int x,int y) {
        x=ifind(x),y=ifind(y);
        if(x!=y) p[x]=y;
    }
} bcc,S;

namespace LCT {

    struct Node {
        Node *ch[2],*fa;
        int v,rev,sum;
        Node() {}
        Node(int x) ;
        void reverse() {
            rev^=1;
            swap(ch[0],ch[1]);
        }
        void up_push() {
            if(fa->ch[0]==this||fa->ch[1]==this) 
                fa->up_push();
            if(rev) {
                ch[0]->reverse();
                ch[1]->reverse();
                rev=0;
            }
        }
        void maintain() {
            sum=v+ch[0]->sum+ch[1]->sum;
        }
    } T[N],*null=&T[0];
    Node::Node(int x) {
        rev=0;
        v=sum=x;
        ch[0]=ch[1]=fa=null;
    }
    
    void rot(Node* o,int d) {
        Node *p=o->fa;
        p->ch[d]=o->ch[d^1];
        o->ch[d^1]->fa=p;
        o->ch[d^1]=p;
        o->fa=p->fa;
        if(p==p->fa->ch[0])
            p->fa->ch[0]=o;
        else if(p==p->fa->ch[1])
            p->fa->ch[1]=o;
        p->fa=o;
        p->maintain();
    }
    void splay(Node *o) {
        o->up_push();
        Node *nf,*nff;
        while(o->fa->ch[0]==o||o->fa->ch[1]==o) {
            nf=o->fa,nff=nf->fa;
            if(o==nf->ch[0]) {
                if(nf==nff->ch[0]) rot(nf,0);
                rot(o,0);
            } else {
                if(nf==nff->ch[1]) rot(nf,1);
                rot(o,1);
            }
        }
        o->maintain();
    }
    void Access(Node *o) {
        Node *son=null;
        while(o!=null) {
            splay(o);
            o->ch[1]=son;
            o->maintain();
            o->fa=&T[bcc.ifind(o->fa-T)];
            son=o; o=o->fa;
        }
    }
    void evert(Node *o) {
        Access(o); 
        splay(o);
        o->reverse();
    }
    void Link(Node *u, Node *v) {
        evert(u);
        u->fa=v;
    }

}

using namespace LCT;

int n,m,a[N];

void merge(Node* &u,Node* v) 
{
    if(u==null) return ;
    v->v+=u->v;
    bcc.iunion(u-T,v-T);
    merge(u->ch[0],v);
    merge(u->ch[1],v);
    u=null;
}

int main()
{
    n=read(),m=read();
    FOR(i,1,n) {
        a[i]=read(); T[i]=Node(a[i]);
    }
    int op,u,v;
    FOR(i,1,m) {
        op=read(),u=read(),v=read();
        if(op==1) {
            u=bcc.ifind(u),v=bcc.ifind(v);
            if(u==v) continue;
            if(S.ifind(u)!=S.ifind(v))
                Link(&T[u],&T[v]),
                S.iunion(u,v);
            else {
                evert(&T[u]);
                Access(&T[v]),splay(&T[v]);
                merge(T[v].ch[0],&T[v]);
                merge(T[v].ch[1],&T[v]);
                T[v].maintain();
            }
        } else 
        if(op==2) {
            splay(&T[bcc.ifind(u)]);
            T[bcc.ifind(u)].v+=v-a[u];
            T[bcc.ifind(u)].maintain();
            a[u]=v;
        } else {
            u=bcc.ifind(u),v=bcc.ifind(v);
            if(S.ifind(u)!=S.ifind(v)) puts("-1");
            else {
                evert(&T[u]);
                Access(&T[v]),splay(&T[v]);
                printf("%d\n",T[v].sum);
            }
        }
    }
    return 0;
}

 

 

Q:打码的最怕什么

A:手残和眼瞎。

真不巧，我两样都是