Luogu 3302 [SDOI2013]森林

BZOJ 3123

丑陋的常数，BZOJ 19968ms 卡过。

感觉几个思想都挺经典但是挺套路的。

先考虑不连边的情况怎么做，区间第$k$小，想到主席树，每一个结点维护它到根的前缀和，这样子每一次查询$x$到$y$链上的点就相当于主席树上$sum(x) + sum(y) - sum(lca(x, y)) - sum(fa(lca(x, y)))$，时间复杂度一个$log$。

然后想一想连边怎么做，因为我们要维护一个森林的形态，如果暴力连边的话，相当于把$y$作为根建树连到$x$上，我们有一个优化暴力的办法就是每一次都把$siz$小的那一个点建树连到另一个点。

然后发现这样的复杂度就已经对了，证明方法和树剖类似，相当于每一次合并$siz$都会至少扩大一倍，所以对于一个大小为$n$的集合，至多会合并$logn$次，总复杂度$O(nlogn)$，这东西有一个名字叫做启发式合并。

时间复杂度$O(nlog^{2}n)$。

还有一个算是坑点的东西：

（我也是）

虽然感觉题目说得很清楚了，但是我还是没有看

Code：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = ;
const int Lg = ;
const int M = 4e7 + ;
const int inf =  << ;

int testCase, n, m, qn, tot, head[N];
int ans, maxn, ufs[N], siz[N];
int fa[N][Lg], dep[N], a[N], v[N];
bool vis[N];

struct Edge {
    int to, nxt;
} e[N << ];

inline void add(int from, int to) {
    e[++tot].to = to;
    e[tot].nxt = head[from];
    head[from] = tot;
}

struct Innum {
    int val, id;
} in[N];

bool cmp(const Innum &x, const Innum &y) {
    if(x.val != y.val) return x.val < y.val;
    else return x.id < y.id;
}

inline void chkMax(int &x, int y) {
    if(y > x) x = y;
}

inline void discrete() {
    sort(in + , in +  + n, cmp);
    in[].val = -inf;

    for(int cnt = , i = ; i <= n; i++) {
        if(in[i].val != in[i - ].val) chkMax(maxn, ++cnt);
        a[in[i].id] = cnt;
        v[cnt] = in[i].val;
    }
}

inline void read(int &X) {
    X = ; char ch = ; int op = ;
    for(; ch > '' || ch < ''; ch = getchar())
        if(ch == '-') op = -;
    for(; ch >= '' && ch <= ''; ch = getchar())
        X = (X << ) + (X << ) + ch - ;
    X *= op;
}

inline void init() {
    for(int i = ; i <= n; i++)
        ufs[i] = i, siz[i] = ;
}

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

namespace PSegT {
    struct Node {
        int lc, rc, sum;
    } s[M];
    int root[N], nodeCnt;

    #define mid ((l + r) >> 1)

    inline void up(int p) {
        if(!p) return;
        s[p].sum = s[s[p].lc].sum + s[s[p].rc].sum;
    }

    void ins(int &p, int l, int r, int x, int pre) {
        s[p = ++nodeCnt] = s[pre], s[p].sum++;
        if(l == r) return;

        if(x <= mid) ins(s[p].lc, l, mid, x, s[pre].lc);
        else ins(s[p].rc, mid + , r, x, s[pre].rc);

        up(p);
    }

    int query(int x, int y, int z, int w, int l, int r, int k) {
        if(l == r) return l;

        int now = s[s[x].lc].sum + s[s[y].lc].sum - s[s[z].lc].sum - s[s[w].lc].sum;

        if(k <= now) return query(s[x].lc, s[y].lc, s[z].lc, s[w].lc, l, mid, k);
        else return query(s[x].rc, s[y].rc, s[z].rc, s[w].rc, mid + , r, k - now);
    }

} using namespace PSegT;

void dfs1(int x, int fat) {
    vis[x] = , dep[x] = dep[fat] + , fa[x][] = fat;
    for(int i = ; i <= ; i++)
        fa[x][i] = fa[fa[x][i - ]][i - ];
    for(int i = head[x]; i; i = e[i].nxt) {
        int y = e[i].to;
        if(y == fat) continue;
        dfs1(y, x);
    }
}

inline void swap(int &x, int &y) {
    int t = x; x = y; y = t;
}

inline int getLca(int x, int y) {
    if(dep[x] < dep[y]) swap(x, y);
    for(int i = ; i >= ; i--)
        if(dep[fa[x][i]] >= dep[y])
            x = fa[x][i];
    if(x == y) return x;
    for(int i = ; i >= ; i--)
        if(fa[x][i] != fa[y][i])
            x = fa[x][i], y = fa[y][i];
    return fa[x][];
}

void dfs2(int x) {
    root[x] = , ins(root[x], , maxn, a[x], root[fa[x][]]);
    for(int i = head[x]; i; i = e[i].nxt) {
        int y = e[i].to;
        if(y == fa[x][]) continue;
        dfs2(y);
    }
}

inline void solve() {
    int x, y, k;
    read(x), read(y), read(k);
    x ^= ans, y ^= ans, k ^= ans;
    int z = getLca(x, y), w = fa[z][];
    int res = query(root[x], root[y], root[z], root[w], , maxn, k);
    printf("%d\n", ans = v[res]);
}

int main() {
    read(testCase);
    for(testCase = ; testCase--; ) {
        read(n), read(m), read(qn);

        memset(head, , sizeof(head)); tot = maxn = ;
        init();

        for(int i = ; i <= n; i++) {
            read(a[i]);
            in[i] = (Innum) {a[i], i};
        }
        discrete();

        for(int x, y, i = ; i <= m; i++) {
            read(x), read(y);
            add(x, y), add(y, x);

            int fx = find(x), fy = find(y);
            if(fx != fy) {
                ufs[fx] = fy;
                siz[fy] += siz[fx];
            }
        }

        memset(vis, , sizeof(vis));
        memset(root, , sizeof(root)); nodeCnt = ;
        for(int i = ; i <= n; i++) {
            if(vis[i]) continue;
            dfs1(find(i), ), dfs2(find(i));
        }

        ans = ;
        for(char op[]; qn--; ) {
            scanf("%s", op);
            if(op[] == 'Q') solve();
            else {
                int x, y;
                read(x), read(y);
                x ^= ans, y ^= ans;

                int fx = find(x), fy = find(y);
                if(siz[fx] > siz[fy]) swap(fx, fy);

                add(x, y), add(y, x);
                dfs1(y, x), dfs2(y);

                ufs[fy] = fx, siz[fx] += siz[fy];
            }
        }

    }
    return ;
}