Description

給出n個結點以及每個點初始時對應的權值wi。起始時點與點之間沒有連邊。有3類操作：
1、bridge A B：詢問結點A與結點B是否連通。如果是則輸出“no”。否則輸出“yes”，並且在結點A和結點B之間連一條無向邊。
2、penguins A X：將結點A對應的權值wA修改為X。
3、excursion A B：如果結點A和結點B不連通，則輸出“impossible”。否則輸出結點A到結點B的路徑上的點對應的權值的和。
給出q個操作，要求線上處理所有操作。資料範圍：1<=n<=30000, 1<=q<=300000, 0<=wi<=1000。

Input

第一行包含一個整數n(1<=n<=30000)，表示節點的數目。第二行包含n個整數，第i個整數表示第i個節點初始時對應的權值。第三行包含一個整數q(1<=n<=300000)，表示操作的數目。以下q行，每行包含一個操作，操作的類別見題目描述。任意時刻每個節點對應的權值都是1到1000的整數。

Output

輸出所有bridge操作和excursion操作對應的輸出，每個一行。

題解

一、LCT

本題最基本的方法

#include<cstdio>
#include<cstring>
#include<algorithm>
 


using namespace std;
#define N 60010
#define lson node[o].ls
#define rson node[o].rs

struct LCT{
    struct Node{
        int idx,fa,ls,rs,path_fa;
    } node[N];
    int cnt,pos[N],a[N],tot[N];
    bool ch[N];

    inline void maintain(int o)
    {
        if(ch[o]) {
            ch[o] = false;
            ch[lson] = !ch[lson]; ch[rson] = !ch[rson];
            swap(lson,rson);
        }
        tot[o] = tot[lson] + tot[rson] + a[node[o].idx];
    }

    void
 
 l_rotate(int o)
    {
        int y = node[o].fa;
        node[o].path_fa = node[y].path_fa;
        node[y].path_fa = 0;
        node[y].rs = lson;
        int tmp = tot[y];
        tot[y] = tot[y] - tot[o] + tot[lson];
        tot[o] = tmp;
        if(lson) node[lson].fa = y;
        node[o].fa = node[y].fa;
        if(node[y].fa) {
            if(y == node[node[y].fa].ls) node[node[y].fa].ls = o;
            else node[node[y].fa].rs = o;
        }
        node[y].fa = o;
        node[o].ls = y;
    }

    void r_rotate(int o)
    {
        int y = node[o].fa;
        node[o].path_fa = node[y].path_fa;
        node[y].path_fa = 0;
        node[y].ls = rson;
        int tmp = tot[y];
        tot[y] = tot[y] - tot[o] + tot[rson];
        tot[o] = tmp;
        if(rson) node[rson].fa = y;
        node[o].fa = node[y].fa;
        if(node[y].fa) {
            if(y == node[node[y].fa].ls) node[node[y].fa].ls = o;
            else node[node[y].fa].rs = o;
        }
        node[y].fa = o;
        node[o].rs = y;
    }

    void splay(int o)
    {
        while(node[o].fa) {
            int pa = node[o].fa;
            maintain(pa);
            if(node[pa].ls) maintain(node[pa].ls);
            if(node[pa].rs) maintain(node[pa].rs);
            if(o == node[node[o].fa].ls) r_rotate(o); else l_rotate(o);
        }
    }

    void access(int o)
    {
        splay(o);
        maintain(o);
        int q = rson;
        rson = node[q].fa = 0;
        node[q].path_fa = o;
        maintain(o);
        for(q = node[o].path_fa;q;q = node[o].path_fa) {
            splay(q);
            maintain(q);
            int r = node[q].rs;
            node[r].fa = 0;
            node[r].path_fa = q;
            node[q].rs = o;
            node[o].fa = q;
            node[o].path_fa = 0;
            maintain(q);
            o = q;
        }
        splay(o);
    }

    int find_root(int o)
    {
        access(o); splay(o);
        maintain(o);
        while(lson) o = lson;
        splay(o);
        return o;
    }

    void evert(int o)
    {
        access(o); splay(o);
        ch[o] = !ch[o];
        maintain(o);
    }

    void cut(int p,int q)
    {
        evert(p);
        access(q); splay(q);
        maintain(q);
        node[node[q].ls].fa = 0;
        node[q].ls = 0;
        maintain(q);
    }

    void link(int p,int q)
    {
        evert(p); splay(p); maintain(p);
        access(q); splay(q); maintain(q);
        node[p].ls = q;
        node[q].fa = p;
        maintain(p);
    }

    int sum(int p,int q)
    {
        evert(p); splay(p); maintain(p);
        access(q); splay(q); maintain(q);
        return tot[q];
    }

    void change(int o,int d,int pre)
    {
        splay(o);
        tot[o] += d - pre;
    }

    void init()
    {
        cnt = 0;
        memset(pos,0,sizeof(pos));
        tot[0] = 0;
    }

    void make_tree(int idx,int d)
    {
        a[idx] = d;
        int o = ++cnt;
        pos[idx] = o;
        node[o].fa = lson = rson = node[o].path_fa = 0;
        tot[o] = d;
        node[o].idx = idx;
    }

    int getroot(int idx) { return node[find_root(idx)].idx; }
    void add_edge(int x,int y) { link(pos[x],pos[y]); }
    void destory(int x,int y) { cut(pos[x],pos[y]); }
    int getsum(int x,int y) { return sum(pos[x],pos[y]); }
    void Change(int x,int d) { change(pos[x],d,a[x]); a[x] = d; }
}T;

int n,u,v,q;
char str[20];

int main()
{
    scanf("%d",&n);
    T.init();
    for(int i = 1;i <= n;i++) {
        scanf("%d",&v);
        T.make_tree(i,v);
    }
    scanf("%d",&q);
    while(q--) {
        scanf("%s%d%d",str,&u,&v);
        if(str[0] == 'b') {
            if(T.getroot(u) == T.getroot(v)) puts("no");
            else {puts("yes"); T.add_edge(u,v);}
        }
        else if(str[0] == 'p') T.Change(u,v);
        else {
            if(T.getroot(u) != T.getroot(v)) puts("impossible");
            else printf("%d\n",T.getsum(u,v));
        }
    }
    return 0;
}

二、樹鏈剖分+並查集

　　我個人更喜歡這一種，好寫一點。
　　考慮到本題沒有刪邊操作，所以一開始將所有的新增邊搞出來，確定樹的形態（注意，可能是一棵森林，在樹鏈剖分dfs的時候要注意）
　　然後再用並查集維護連通性即可。

#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;
#define N 30100
#define M 300100

struct node{int to,next;}e[N<<2];
int head[N],tot;

int tid[N],son[N],fa[N],top[N],dep[N],size[N],Rank[N];
int n,a[N],tim;
bool vis[N];

void init()
{
    tot = tim = 0;
    memset(head,0,sizeof(head));
    memset(son,-1,sizeof(son));
    memset(vis,false,sizeof(vis));
}

void add_edge(int from,int to)
{
    e[++tot].next = head[from];
    head[from] = tot;
    e[tot].to = to;
}

void dfs1(int v,int pa,int deep)
{
    dep[v] = deep; fa[v] = pa; size[v] = 1;
    vis[v] = 1;
    for(int i = head[v];i;i = e[i].next)
        if(e[i].to != pa) {
            dfs1(e[i].to,v,deep+1);
            size[v] += size[e[i].to];
            if(son[v] == -1 || size[e[i].to] > size[son[v]])
                son[v] = e[i].to;
        }
}

void dfs2(int v,int tp)
{
    top[v] = tp; tid[v] = ++tim;
    Rank[tid[v]] = v;
    if(son[v] == -1) return;
    dfs2(son[v],tp);
    for(int i = head[v];i;i=e[i].next)
        if(e[i].to != son[v] && e[i].to != fa[v])
            dfs2(e[i].to,e[i].to);
}

int f[N];
int find(int x) { return x == f[x] ? x : f[x] = find(f[x]);}

#define lson o << 1
#define rson o << 1 | 1
int sum[N<<2];

void build(int o,int l,int r)
{
    if(l == r) {sum[o] = a[Rank[l]]; return;}
    int mid = (l+r)>>1;
    build(lson,l,mid); build(rson,mid+1,r);
    sum[o] = sum[lson] + sum[rson];
}

void update(int o,int l,int r,int pos,int v)
{
    if(l == r) {sum[o] = v; return;}
    int mid = (l+r)>>1;
    if(pos <= mid) update(lson,l,mid,pos,v); else update(rson,mid+1,r,pos,v);
    sum[o] = sum[lson] + sum[rson];
}

int query(int o,int l,int r,int ll,int rr)
{
    if(ll <= l && rr >= r) return sum[o];
    int mid = (l+r)>>1;
    int ans = 0;
    if(ll <= mid) ans += query(lson,l,mid,ll,rr);
    if(rr > mid) ans += query(rson,mid+1,r,ll,rr);
    return ans;
}

int Query(int x,int y)
{
    int ans = 0;
    while(top[x] != top[y]) {
        if(dep[top[x]] < dep[top[y]]) swap(x,y);
        ans += query(1,1,n,tid[top[x]],tid[x]);
        x = fa[top[x]];
    }
    if(dep[x] > dep[y]) swap(x,y);
    ans += query(1,1,n,tid[x],tid[y]);
    return ans;
}

int A[M],B[M],opt[M];
int m;
char str[20];
int main()
{
    init();
    scanf("%d",&n);
    for(int i = 1;i <= n;i++) scanf("%d",&a[i]);
    scanf("%d",&m);

    for(int i = 1;i <= n;i++) f[i] = i;
    for(int i = 1;i <= m;i++) {
        scanf("%s%d%d",str,&A[i],&B[i]);
        if(str[0] == 'b') {
            opt[i] = 1;
            int x = find(A[i]),y = find(B[i]);
            if(x != y) {
                f[x] = y;
                add_edge(A[i],B[i]); add_edge(B[i],A[i]);
            }
        }
        if(str[0] == 'p') opt[i] = 2;
        if(str[0] == 'e') opt[i] = 3;
    }
    for(int i = 1;i <= n;i++)
        if(!vis[i]) dfs1(i,0,0),dfs2(i,i);
    build(1,1,n);

    for(int i = 1;i <= n;i++) f[i] = i;
    for(int i = 1;i <= m;i++) {
        if(opt[i] == 1) {
            int x = find(A[i]),y = find(B[i]);
            if(x != y) {puts("yes"); f[x] = y;} else puts("no");
        }
        if(opt[i] == 2) update(1,1,n,tid[A[i]],B[i]);
        if(opt[i] == 3) {
            int x = find(A[i]),y = find(B[i]);
            if(x != y) puts("impossible"); else printf("%d\n",Query(A[i],B[i]));
        }
    }
    return 0;
}