bzoj3123: [Sdoi2013]森林 主席树，子树启发式合并

bzoj3123: [Sdoi2013]森林

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。之后的操作类似。

分析

题目大意：维护一棵动态加边的森林，求森林两点路径上点权第k大。
只有加边的话就是主席树+子树启发式合并。
子树启发式合并的操作就是把小的合并到大的。
这样对于每个点，如果它被合并的话它所在块的大小一定倍增。
于是复杂度神奇地变成了$O(logn)$
然后维护树上第k大的操作就是维护某个节点到根的主席树，求Lca在树上差分。
还有因为是动态加边所以Lca只能用倍增求。
复杂度$O(nlog^2n)$

代码

没有多组数据，被这个卡了好久。。。。

#include<cstdio>
#include<algorithm>
const int N = 1e5, T = 4e7;
int ri() {
    char c = getchar(); int x = 0;  for(;c < '0' || c > '9'; c = getchar()) ; 
    for(;c >= '0' && c <= '9';  c = getchar()) x = (x << 1) + (x << 3) - '0' + c; return x;
}
int to[N << 1], nx[N << 1], d[N], sz[N], g[N], pr[N], rt[N];
int f[N][17], b[N], a[N], ls[T], rs[T], s[T], tp, n, m, t, nn, Sz;
void add(int u, int v) {to[++tp] = v; nx[tp] = pr[u]; pr[u] = tp;}
void adds(int u, int v) {add(u, v); add(v, u);}
int F(int x) {
    int L = 1, R = nn, m;
    for(;L != R;b[m = L + R >> 1] < x ? L = m + 1 : R = m) ;
    return L;
}
void Ins(int &c, int p, int L, int R, int v) {
    s[c = ++Sz] = s[p] + 1;
    if(L == R) return ; int m = L + R >> 1;
    v <= m ? rs[c] = rs[p], Ins(ls[c], ls[p], L, m, v) : (ls[c] = ls[p], Ins(rs[c], rs[p], m + 1, R, v));
}
void Dfs(int u, int fa, int g) {
    Ins(rt[u], rt[fa], 1, nn, a[u]); ::g[u] = g; ++sz[g]; d[u] = d[fa] + 1;
    f[u][0] = fa; for(int i = 1;i <= 16; ++i) f[u][i] = f[f[u][i - 1]][i - 1];
    for(int i = pr[u]; i; i = nx[i]) if(to[i] != fa) Dfs(to[i], u, g);
}
void Link(int u, int v) {
    if(sz[g[u]] < sz[g[v]]) u ^= v ^= u ^= v;
    adds(u, v); Dfs(v, u, g[u]);
}
int lca(int u, int v) {
    if(d[u] < d[v]) u ^= v ^= u ^= v;
    for(int i = 16; ~i && d[u] != d[v]; --i) if(d[f[u][i]] >= d[v]) u = f[u][i];
    if(u == v) return u;
    for(int i = 16; ~i; --i) if(f[u][i] != f[v][i]) u = f[u][i], v = f[v][i];
    return f[u][0];
}
int Que(int u, int v, int k) {
    int t = lca(u, v), g = f[t][0];
    int L = 1, R = nn, l1 = rt[u], l2 = rt[v], r1 = rt[t], r2 = rt[g];
    for(;L != R;) {
        int m = L + R >> 1, sl = s[ls[l1]] + s[ls[l2]] - s[ls[r1]] - s[ls[r2]];
        if(sl >= k) l1 = ls[l1], l2 = ls[l2], r1 = ls[r1], r2 = ls[r2], R = m;
        else k -= sl, l1 = rs[l1], l2 = rs[l2], r1 = rs[r1], r2 = rs[r2], L = m + 1;
    }
    return b[L];
}
int main() {
    ri(); n = ri(); m = ri(); t = ri(); 
    for(int i = 1;i <= n; ++i) b[i] = a[i] = ri();
    std::sort(b + 1, b + n + 1);
    nn = 1; for(int i = 2;i <= n; ++i) if(b[i] != b[i - 1]) b[++nn] = b[i];
    for(int i = 1;i <= n; ++i) a[i] = F(a[i]);
    for(int u, v, w;m--;) u = ri(), v = ri(), adds(u, v);
    for(int i = 1;i <= n; ++i) if(!g[i]) Dfs(i, 0, i);
    for(int la = 0, x, y;t--;) {
        char op = getchar(); for(;op != 'Q' && op != 'L';) op = getchar();
        x = ri() ^ la; y = ri() ^ la;
        if(op == 'Q') printf("%d\n", la = Que(x, y, ri() ^ la));
        else Link(x, y);
    }
    return 0;
}