并查集几道题目

最基础的操作

查找某元素的所在的集合，即该元素的根节点。顺便做了路径压缩

int pre[MAX];

int find(int x){
	int r = x;
	while(r != pre[r]) r = pre[r];//循环向前，直到找到根节点（自己是自己的父节点）
	int i = x, j;
	while (i != pre[i]){
		j = pre[i];
		pre[i] = r;//状态压缩,寻根路径上的点都直接指向根节点
		i = j;
	}
	return r;
}

加入某集合中

void join(int a, int b){
	int fa = find(a);
	int fb = find(b);
	if (fa != fb)
		pre[fa] = fb;
}

洛谷OJ P1196银河英雄传说—带权并查集

这里因为要求两个元素之间的元素个数，一开始自然想到了用两个方向的并查集，但这样就成了双向数组了，其实并没有必要。根据KISS原则，只需要再加两个辅助数组即可，这样便成了带权并查集。
一个是pre[],用于记录该元素前面（包含该元素）有几个元素；一个是counts[]，用于记录该元素所在列元素的总个数，这里只要更新根节点的值就好了，还有count是algorithm的函数，不能用这个做数组的名字。
最需要注意的一点，这里的权值–即某元素前面的元素个数，是需要在每次find时更新的，因为合并时只能修改这个队列头元素的pre[]值，后面的要在find这个元素时进行修改，正好和状态压缩一起完成了。

#include <iostream>
#include <algorithm>
#include <stdio.h> 
#define MAX 30000+1
using namespace std;

int pre[MAX] = {0}, father[MAX] = {0}, counts[MAX] = {0};

void show(int n){//及时打印出关键数据是debug的好方法
	for (int i=1; i<=n; i++){
		printf("%dth: father-%d counts-%d pre-%d\n", i, father[i], counts[i], pre[i]);
	}
	cout<<endl;
}

int find(int x){
	if (x != father[x]){
		int f = find(father[x]);//通过递归查找根节点，代码更加简洁了
		pre[x] += pre[father[x]];//每一层递归都会更新该节点的pre[]，因为有状态压缩，所以不用担心重复增加，最后pre[root]一定是为0的
		father[x] = f;//实现状态压缩，每一层递归中都实现了一遍
	}
	return father[x];//返回值
}

void join(int a, int b){
	int ha = find(a);
	int hb = find(b);
	if (ha != hb){
		father[ha] = hb;//只把原来队列的根节点并过去即可
		pre[ha] += counts[hb];//先只能更新原来队列根节点的pre[]值
		counts[hb] += counts[ha];//更新合并后根节点的队列长度值，后面只用根节点的值就行了，后面的不必更新
	}	
}

int query(int a, int b){
	int ha = find(a);
	int hb = find(b);
	show(5);
	if (ha != hb)
		return -1;
	else{
		return abs(pre[a] - pre[b])-1;
	}	
		
}

int main(){
	int T, a, b;
	char CMD;
	cin>>T;
	for (int i=1; i<=30000; i++){
		father[i] = i;
		counts[i] = 1;
		pre[i] = 0;
	}
	for (int i=0; i<T; i++){
		cin>>CMD>>a>>b;
		if (CMD == 'M'){
			join(a, b);
			show(5);
		}else if (CMD == 'C'){
			cout<<query(a, b)<<endl;
		}
	}
	return 0;
}