笔记②：并查集算法解析及其高级运用（POJ1182 食物链代码解析）

1   并查集是一种树型的数据结构，用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。常常在使用中以森林来表示。

    需要实现的操作有：合并两个集合，判断两个元素是否属于一个集合。
    这里介绍的主要是普通的并查集，很多情况下使用的并查集是需要扩展的，根据使用情况的不同，有很多差别，这里仅仅是最基本的算法。

2. 复杂度

    T=O(n*α(n)) ， 其中α(x)，对于x=宇宙中原子数之和，α(x)不大于4。事实上，路经压缩后的并查集的复杂度是一个很小的常数即O（α(n)）。

(α(n)是阿克曼（Ackermann）函数的反函数。这比O(log(n))还要快。)
3. 伪代码   

    没有使用路径压缩和启发式的方法。

// 初始化并查集

#define N 100

int father[N];

void init() {

    for(int i=0; i

      father[i] = i;

}

//  合并两个元素所在的集合
void  union( int  x, int  y) {
    x  =  getfather(x);
    y  =  getfather(y);
     if (x != y )
       father[x] = y;
}
//  判断两个元素是否属于同一个集合
bool  same( int  x, int  y) {
     return  getfather(x) == getfather(y);
}
//  获取根结点
int  getfather( int  x) {
     while (x != father[x] )
      x  =  father[x];
     return  x;
}

    使用路径压缩，改进getfather。

//  获取根结点
int  getfather( int  x) {
     if (x  !=  father[x])
      father[x]  =  getfather(father[x]); // 路径压缩修改的是father数组

     return  father[x];
}

    另外，还可以改进union，把数量少的集合合并到数量大的集合中，不过这就要记录

每个集合中的元素数量，相当于增加了O（N）的存储空间，而且在getfather中也应该

保持对元素数量的维护，相对代码复杂度偏高，代码如下（复杂度变为 O(α(n)) )：

		        int father[MAXN], Rank[MAXN];
				//初始化n个元素
			void Init(int n)
			{
				int i;
				for (i = 1; i <= n; i++)
					father[i] = i;
				Rank[i] = 0;
			}
			//查询树的根
			int find(int x) {
				if (father[x] == x)return x;
				return father[x] = find(father[x]);
			}
			//合并x和y所属的集合
			void Unite(int x, int y) {
				x = find(x);
				y = find(y);
				if (x == y)return;
				if (Rank[x] > Rank[y]) {
					father[y] = x;
				}
				else {
					father[x] = y;
					if (Rank[x] == Rank[y])Rank[x]++;
				}              
			}
			//判断x和y是否属于同一个集合
			bool same(int x, int y) {
				return find(x)== find(y);
			}

直接上这一道经典到不能再经典的并查集题目：

食物链

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 26553		Accepted: 7718

Description

动物王国中有三类动物A,B,C，这三类动物的食物链构成了有趣的环形。A吃B， B吃C，C吃A。 
现有N个动物，以1－N编号。每个动物都是A,B,C中的一种，但是我们并不知道它到底是哪一种。 
有人用两种说法对这N个动物所构成的食物链关系进行描述： 
第一种说法是"1 X Y"，表示X和Y是同类。 
第二种说法是"2 X Y"，表示X吃Y。 
此人对N个动物，用上述两种说法，一句接一句地说出K句话，这K句话有的是真的，有的是假的。当一句话满足下列三条之一时，这句话就是假话，否则就是真话。 
1） 当前的话与前面的某些真的话冲突，就是假话； 
2） 当前的话中X或Y比N大，就是假话； 
3） 当前的话表示X吃X，就是假话。 
你的任务是根据给定的N（1 <= N <= 50,000）和K句话（0 <= K <= 100,000），输出假话的总数。 

Input

第一行是两个整数N和K，以一个空格分隔。 
以下K行每行是三个正整数 D，X，Y，两数之间用一个空格隔开，其中D表示说法的种类。 
若D=1，则表示X和Y是同类。 
若D=2，则表示X吃Y。

Output

只有一个整数，表示假话的数目。

Sample Input

100 7
1 101 1 
2 1 2
2 2 3 
2 3 3 
1 1 3 
2 3 1 
1 5 5

Sample Output

3

题意：

三类动物A、B、C构成食物链循环，告诉两个动物的关系（同类或天敌），判断那个关系是和前面已有的冲突。

分析：

并查集的高级应用。

假设father[A]=B ，rank[A]=0表示A与B同类；rank[A]=1 表示B可以吃A；rank[A]=2 表示A可以吃B。

对于一组数据 d x y，若x与y的根节点相同，利用(rank[y]-rank[x]+3)%3!=d-1若不相等说明为假话；

若x与y根节点不同，说明两者不在同一集合里，进行组合。让x的根fx成为y的根fy的父节点（father[fy]=fx），rank[fy]的值需要仔细归纳得出。

#include   
#include   

#define MAXN 50001  
int father[MAXN], Rank[MAXN];

void Init(int n)
{
	int i;
	for (i = 1; i <= n; i++)
		father[i] = i;
	memset(Rank, 0, sizeof(Rank));
}
int Find_Set(int x)
{
	if (x != father[x])
	{
		int fx = Find_Set(father[x]);
		Rank[x] = (Rank[x] + Rank[father[x]]) % 3;    //注意 是rank[father[x]]而不是rank[fx]  
		//(儿子relation + 父亲relation) % 3 = 儿子对爷爷的relation 下面会有归纳证明
		father[x] = fx;
	/*这个还是有必要解释一下的，原本Rank[x]是x与父节点father[x]的关系，而由于父节点father[x]在不断变化
	直到变成根节点（所以Rank[x]也要不断更新直到确定与根节点的关系）
	如何更新？我们可以总结出如下规律：
	//我们可以用动物之间“相对”的关系来确定一个并查集。
	//0 - 这个节点与它的父节点是同类
	//1 - 这个节点被它的父节点吃
	//2 - 这个节点吃它的父节点。
                  i      j                                  j是儿子与父亲的关系，i是父亲与爷爷的关系
     爷爷  父亲  儿子  儿子与爷爷
		     0      0       (i + j) % 3 = 0  
		     0      1       (i + j) % 3 = 1
		     0      2       (i + j) % 3 = 2
		     1      0       (i + j) % 3 = 1
		     1      1       (i + j) % 3 = 2
		     1      2       (i + j) % 3 = 0
		     2      0       (i + j) % 3 = 2
		     2      1       (i + j) % 3 = 0
		     2      2       (i + j) % 3 = 1
		嗯，这样可以看到，(儿子relation + 父亲relation) % 3 = 儿子对爷爷的relation
		这就是路径压缩的节点算法

		所以每次都用Rank[x] = (Rank[x] + Rank[father[x]]) % 3;来更新x 与 x的父亲的父亲 的关系
		即x（儿子）与爷爷的关系，而这个变化的爷爷节点会不断延伸至根节点（递归寻根），所以
		只有通过不断地更新关系最后当到达根节点时，Rank[x]就是x与根节点的关系。*/
	}
	return father[x];
}

bool Union(int x, int y, int type)
{
	int fx, fy;
	fx = Find_Set(x);
	fy = Find_Set(y);
	if (fx == fy)
	{
		if ((Rank[y] - Rank[x] + 3) % 3 != type)return true;   
		//通过上面的关系图可以得到，若不符合上述关系则返回true表示 错误的说法要+1
		else return false;
	}
	father[fy] = fx;
	Rank[fy] = (Rank[x] - Rank[y] + type + 3) % 3;   
	/*这个怎么来的呢？
	首先x和y是不同根的（fx!=fy）,此时进行并根操作（father[fy]=fx）,fy的父亲变为fx，
	即fx是总根节点，有fx←x，fx←fy←y。
		由上面的关系: (儿子relation + 父亲relation) % 3 = 儿子对爷爷的relation可以得到：
	(Rank[x]+type+3)%3即可得到 fx 与 y 的关系, 设为Rank[fx←y]
	这是因为Rank[x]为fx与x关系，type是x与y的关系(即d - 1)
	而同理(Rank[fy] + Rank[y] + 3) % 3=Rank[fx←y]
   这是因为有fx←fy←y,而此时Rank[fy]是要求的，所以可以得到：
		Rank[fy]=(Rank[fx←y]-Rank[y]+3)%3
		将Rank[fx←y]=(Rank[x] + type + 3) % 3代入即可得：
		Rank[fy] = (Rank[x] - Rank[y] + type + 3) % 3;*/
	return false;
}

int main()
{
	//freopen("in.txt", "r", stdin);
	int n, k;
	int sum, i;
	int d, x, y;
	scanf("%d %d", &n, &k);
	//cin>>n>>k;  
	Init(n);
	sum = 0;
	for (i = 0; i>d>>x>>y;                   //用cin会超时  
		if (x>n || y>n || (x == y && d == 2))
			sum++;
		else if (Union(x, y, d - 1))         //传d-1 方便关系式的表达  
			sum++;
	}
	printf("%d\n", sum);
	return 0;
}

部分内容参考两篇博文   http://blog.csdn.net/c0de4fun/article/details/7318642/

                                                           http://blog.csdn.net/tiantangrenjian/article/details/7085575