bzoj 3123 [Sdoi2013]森林（主席树，lca，启发式合并）

 

Description

 

Input

第一行包含一个正整数testcase，表示当前测试数据的测试点编号。保证1≤testcase≤20。
第二行包含三个整数N，M，T，分别表示节点数、初始边数、操作数。第三行包含N个非负整数表示 N个节点上的权值。
 接下来 M行，每行包含两个整数x和 y，表示初始的时候，点x和点y 之间有一条无向边, 接下来 T行，每行描述一个操作，格式为“Q x y k”或者“L x y ”，其含义见题目描述部分。

Output

对于每一个第一类操作，输出一个非负整数表示答案。 
 
 

Sample Input

1
8 4 8
1 1 2 2 3 3 4 4
4 7
1 8
2 4
2 1
Q 8 7 3 Q 3 5 1
Q 10 0 0
L 5 4
L 3 2 L 0 7
Q 9 2 5 Q 6 1 6

Sample Output

2
2
1
4
2

HINT

 

对于第一个操作 Q 8 7 3，此时 lastans=0，所以真实操作为Q 8^0 7^0 3^0，也即Q 8 7 3。点8到点7的路径上一共有5个点，其权值为4 1 1 2 4。这些权值中，第三小的为 2，输出 2，lastans变为2。对于第二个操作 Q 3 5 1 ，此时lastans=2，所以真实操作为Q 3^2 5^2 1^2 ，也即Q 1 7 3。点1到点7的路径上一共有4个点，其权值为 1 1 2 4 。这些权值中，第三小的为2，输出2，lastans变为 2。之后的操作类似。 

 

 

【思路】

 

       主席树+倍增lca+启发式合并

       如果没有连边操作的话就是luo主席树。两棵树要相连，那一棵在上面无所谓，因为我们要遍历处于下方的树的所有节点所以我们采用启发式合并，即每次选择结点数更小的树放在下面，然后重建每一个结点。

 

 

【代码】

#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;

const int N = 100002;
const int M = 400*N;
const int D = 17;

struct Tnode {
    int sum,lc,rc;
} T[M];

int n,m,q,sz,rt[N];
int p[N],siz[N];
int fa[N][D],hash[N],dep[N];
int v[N],tot;
vector<int> g[N];

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

int ifind(int u)
{
    while(fa[u][0]) u=fa[u][0];
    return u;
}
void insert(int l,int r,int x,int& y,int num)
{
    T[y=++sz]=T[x]; T[y].sum++;
    if(l==r) return ;
    int mid=(l+r)>>1;
    if(num<=mid) insert(l,mid,T[x].lc,T[y].lc,num);
    else insert(mid+1,r,T[x].rc,T[y].rc,num);
}
void dfs(int u,int f)
{
    dep[u]=dep[f]+1; fa[u][0]=f; siz[u]=1;
    insert(1,tot,rt[f],rt[u],v[u]);
    FOR(i,1,D-1)                                                        //p1
        fa[u][i]=fa[fa[u][i-1]][i-1];
    FOR(i,0,(int)g[u].size()-1) {
        int v=g[u][i];
        if(v!=f) {
            dfs(v,u);
            siz[u]+=siz[v];
        }
    }
}
int lca(int u,int v)
{
    if(dep[u]<dep[v]) swap(u,v);
    int t=dep[u]-dep[v];
    FOR(j,0,D-1)
        if(t&(1<<j)) u=fa[u][j];
    if(u==v) return u;
    for(int j=D-1;j>=0;j--)
        if(fa[u][j]!=fa[v][j]) u=fa[u][j],v=fa[v][j];
    return fa[u][0];
}
int query(int l,int r,int a,int b,int c,int d,int rk)
{
    if(l==r) return l;
    int mid=(l+r)>>1;
    int now=T[T[a].lc].sum+T[T[b].lc].sum-T[T[c].lc].sum-T[T[d].lc].sum;
    if(rk<=now) return query(l,mid,T[a].lc,T[b].lc,T[c].lc,T[d].lc,rk);
    else return query(mid+1,r,T[a].rc,T[b].rc,T[c].rc,T[d].rc,rk-now);
}
int query(int x,int y,int z)
{
    int c=lca(x,y);
    return query(1,tot,rt[x],rt[y],rt[c],rt[fa[c][0]],z);
}

int main()
{
        int kase; read(kase);
        read(n),read(m),read(q);
        FOR(i,1,n) {
            read(v[i]); hash[i]=v[i];
            fa[i][0]=0;
        }
        sort(hash+1,hash+n+1);
        tot=unique(hash+1,hash+n+1)-hash-1;
        FOR(i,1,n)
            v[i]=lower_bound(hash+1,hash+tot+1,v[i])-hash;
        char op[5];
        int ans=0,x,y,z;
        FOR(i,1,m) {
            read(x),read(y);
            g[x].push_back(y);
            g[y].push_back(x);
        }
        FOR(i,1,n) if(!fa[i][0]) dfs(i,0);
        FOR(i,1,q) {
            scanf("%s",op);
            read(x),read(y);
            x^=ans; y^=ans;
            if(op[0]=='Q') {
                read(z);
                z^=ans;
                printf("%d\n",ans=hash[query(x,y,z)]);
            } else {
                int fx=ifind(x),fy=ifind(y);
                if(siz[fx]<siz[fy])
                        swap(fx,fy),swap(x,y);
                siz[fx]+=siz[fy];
                g[x].push_back(y);
                g[y].push_back(x);
                dfs(y,x);
            }
        }
        return 0;
}