BZOJ 3123 [SDOI2013] 森林 - 启发式合并 主席树

Description

给你一片森林， 支持两个操作： 查询$x$到$y$的$K$大值，  连接两棵树中的两个点

Solution

对每个节点$x$动态开权值线段树， 表示从$x$到根节点路径上权值出现的次数。

查询时差分即可： $sum[x]+sum[y]-sum[lca]-sum[f[lca]]$

连边时需要启发式合并，将节点数小的接到节点数大的上去， 再遍历小的树， 并更新权值

我刚开始以为testcase是数据组数， TLE我好久，，

Code

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define rd read()
 using namespace std;
 
 const int N = 1e5;
 
 int lson[N * ], rson[N * ], sum[N * ], root[N];
 int n, m, T, a[N], b[N], f[N][], head[N], tot, dep[N];
 int father[N], num[N], cnt, nd_num;
 int lastans, Case; 
 
 struct edge {
     int nxt, to;
 }e[N << ];
 
 int read() {
     int X = , p = ; char c = getchar();
     for(; c > '' || c < ''; c = getchar()) if(c == '-') p = -;
     for(; c >= '' && c <= ''; c = getchar()) X = X *  + c - '';
     return X * p;
 }
 
 void add(int u, int v) {
     e[++tot].to = v;
     e[tot].nxt = head[u];
     head[u] = tot;
 }
 
 int find_anc(int x) {
     return father[x] == x ? x : father[x] = find_anc(father[x]);
 }
 
 int find_lca(int x, int y) {
     if(dep[x] < dep[y]) swap(x, y);
     for(int i = ; ~i; --i) if(dep[f[x][i]] >= dep[y])
         x = f[x][i];
     if(x == y) return x;
     for(int i = ; ~i; --i) if(f[x][i] != f[y][i])
         x = f[x][i], y = f[y][i];
     return f[x][];
 }
 
 int fd(int x) {
     return lower_bound(b + , b +  + cnt, x) - b;
 }
 
 void ins(int &o, int now, int l, int r, int pos) {
     o = ++nd_num;
     sum[o] = sum[now] + ;
     lson[o] = lson[now];
     rson[o] = rson[now];
     if(l == r) return;
     int mid = (l + r) >> ;
     if(pos <= mid) ins(lson[o], lson[now], l, mid, pos);
     else ins(rson[o], rson[now], mid + , r, pos);
 }
 
 int query(int x, int y, int lca, int flca, int l, int r, int k) {
     if(l == r) return l;
     int mid = (l + r) >> , tmp;
     if((tmp = sum[lson[x]] + sum[lson[y]] - sum[lson[lca]] - sum[lson[flca]]) >= k) return query(lson[x], lson[y], lson[lca], lson[flca], l, mid, k);
     else return query(rson[x], rson[y], rson[lca], rson[flca], mid + , r, k - tmp);
 }
 
 void dfs(int u) {
     dep[u] = dep[f[u][]] + ;
     for(int i = ; i <= ; ++i)
         f[u][i] = f[f[u][i - ]][i - ];
     ins(root[u], root[f[u][]], , cnt, fd(a[u]));
     for(int i = head[u]; i; i = e[i].nxt) {
         int nt = e[i].to;
         if(nt == f[u][]) continue;
         f[nt][] = u;
         dfs(nt);
     }
 }
 
 int work() {
     lastans = ; tot = ;
     nd_num = ;
 /*    memset(root, 0, sizeof(root));
     memset(lson, 0, sizeof(lson));
     memset(rson, 0, sizeof(rson));
     memset(head, 0, sizeof(head));
     memset(dep, 0, sizeof(dep));*/
     n = rd; m = rd; T = rd;
     for(int i = ; i <= n; ++i) b[i] = a[i] = rd;
     sort(b + , b +  + n);
     cnt = unique(b + , b +  + n) - b - ;
     for(int i = ; i <= n; ++i) father[i] = i, num[i] = ;
     for(int i = ; i <= m; ++i) {
         int u = rd, v = rd;
         int x = find_anc(u), y = find_anc(v);
         father[y] = x;
         num[x] += num[y];
         add(u, v); add(v, u);
     }
     for(int i = ; i <= n; ++i) if(!dep[i]) dfs(i);
     for(int i = ; i <= T; ++i) {
         char c = getchar();
         while(c != 'Q' && c != 'L') c = getchar();
         int u = rd ^ lastans, v = rd ^ lastans;
         if(c == 'Q') {
             int lca = find_lca(u, v), flca = f[lca][], k = rd ^ lastans;
             lastans = query(root[u], root[v], root[lca], root[flca], , cnt, k);
             if(lastans > cnt || lastans < ) return printf("F**k,WA\n"), ;
             lastans = b[lastans];
             printf("%d\n", lastans);
         }
         else {
             int x = find_anc(u), y = find_anc(v);
             if(num[x] < num[y]) {
                 swap(x, y); swap(u, v);
             }
             father[y] = x;
             num[x] += num[y];
             f[v][] = u;
             add(v, u); add(u, v);
             dfs(v);
         }
     }
     return ;
 }
 
 int main()
 {
     Case = rd;
     work();
 }