P3224 [HNOI2012]永无乡 - 平衡树 - 并查集

开n棵平衡树，慢慢合并成一个，用并查集处理连通关系，平衡树处理第k大就好了
因为重要度是不会有重复的，而且是从1到n的，可以开一个数组，表示重要度为k所对应的编号

如何合并？
要善于把一个新问题转化为一个已解决过的问题
我甚至想自己搞出一个新算法处理连通关系，但是用并查集不就好了吗
思维定势：一个题只用一个学过的算法
实际上用平衡树处理了第k大之后，现在只需要思考如何处理一些点的连通关系，那么并查集就是最适合处理的吧，还能找出代表元素作为合并树之后的树根
合并的时候把size小的合到大的上就好了，这就是启发式合并，和并查集按秩合并一个样。。。

如何用并查集处理？
我们只知道某个点所在集合的代表元素，但是代表元素不一定是树根，所以还要再开一个数组，rt[i]表示i点所在的树的树根，然后用树根的权值映射出点的编号就好了。如何维护？若我们要把a树合并到b树上，先把a所在的集合合并到b上，使ab集合的代表元素仍然是b集合的代表元素，那么r[a]是什么已经无所谓了，只需要维护r[b]，对平衡树搞启发式合并的时候动态维护就好了（就是函数里加个引用）

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
#define debug(x) cerr << #x << "=" << x << endl;
const int MAXN = 200000 + 10;
typedef long long ll;
struct fhq_treap{
    int l, r, siz, val, rnd;
}tr[MAXN]; 
int n,a[MAXN],root,x,y,z,rt[MAXN],fa[MAXN],tot,m,q,rev[MAXN];

inline void read(int &x) {
    x = 0;
    char ch = getchar();
    while(ch < '0' || ch > '9') ch = getchar();
    while(ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
}

void update(int now) {
    tr[now].siz = tr[tr[now].l].siz + tr[tr[now].r].siz + 1;
}

int newnode(int x) {
    tr[++tot].val = x;
    tr[tot].rnd = rand();
    tr[tot].siz = 1;
    return tot;
}

int merge(int x, int y) {
    if(!x || !y) return x + y;
    if(tr[x].rnd < tr[y].rnd) {
        tr[x].r = merge(tr[x].r, y);
        update(x);
        return x;
    }
    tr[y].l = merge(x, tr[y].l);
    update(y);
    return y;
}

void split(int now, int k, int &x, int &y) {
    if(!now) {
        x = y = 0;
        return;
    }
    if(tr[now].val <= k) {
        x = now;
        split(tr[now].r, k, tr[now].r, y);
    } else {
        y = now;
        split(tr[now].l, k, x, tr[now].l);
    }
    update(now);
}

int kth(int now, int k) {
    while(1) {
        int ls = tr[now].l, rs = tr[now].r;
        if(k <= tr[ls].siz) {
            now = ls;
        } else {
            if(k == tr[ls].siz+1) return now;
            k -= tr[ls].siz + 1;
            now = rs;
        }
    }
} 

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

void ufs_merge(int x, int y) {
    int fx = find(x), fy = find(y);
    fa[fx] = fy;
}

bool judge(int x, int y) {
    return find(x) == find(y);
}

void trav(int now, int &tar) {
    if(!now) return;
    int val = tr[now].val;
    split(tar, val, x, y);
    tar = merge(merge(x, newnode(val)), y);
    trav(tr[now].l, tar);
    trav(tr[now].r, tar);
}

void heu_merge(int a, int b) {
    if(tr[rt[a]].siz > tr[rt[b]].siz) swap(a, b);
    ufs_merge(a, b);
    trav(rt[a], rt[b]);
}

int main() {
    scanf("%d%d", &n, &m);
    for(int i=1; i<=n; i++) {
        int temp_val = 0;
        read(temp_val);
        rev[temp_val] = i;
        rt[i] = merge(rt[i], newnode(temp_val));
    }
    for(int i=1; i<=n; i++) {
        fa[i] = i;
    }
    for(int i=1; i<=m; i++) {
        int ai, bi;
        read(ai), read(bi);
        if(!judge(ai, bi)) {
            heu_merge(find(ai), find(bi));
        }
    }
    scanf("%d", &q);
    char ch[5];
    for(int i=1; i<=q; i++) {
        int x, y;
        scanf("%s%d%d", ch, &x, &y);
        if(ch[0] == 'Q') {
            int sym = find(x);
             if(y > tr[rt[sym]].siz) {
                printf("-1\n");
             } else {
                printf("%d\n",rev[tr[kth(rt[sym], y)].val]);
             }
        } else {
            if(!judge(x, y)) {
                heu_merge(find(x), find(y));
            }
        }
    }
    return 0;
}

转载于:https://www.cnblogs.com/Zolrk/p/9785083.html