并查集经典扩展-pku1182(食物链)-并查集用于等价类问题

并查集的普通应用包括，计算最小生成树的kruscal算法和无向图的连通性问题。
这个题目是并查集的一个扩展应用，用于解决等价类问题。

问题描述:
动物王国中有三类动物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），输出假话的总数。
输入:
第一行是两个整数N和K，以一个空格分隔。

以下K行每行是三个正整数 D，X，Y，两数之间用一个空格隔开，其中D表示说法的种类。

若D=1，则表示X和Y是同类。

若D=2，则表示X吃Y。
输出:
只有一个整数，表示假话的数目。

算法思路：
在原有parent[]的基础上加上另一关系relative[x],用于表示动物x相对于其根节点的关系:
1.
如果relative[x]=0, 说明x和根节点的关系是同类
2.
如果relative[x]=1, 说明x和根节点的关系是x吃根节点
3.
如果relative[x]=2, 说明x被根节点吃。

由于再输入的时候也会输入x和y的关系D，题目中说D=1表示x和y是同类，D=2表示x吃y，与relative[]关系表示有出入，所以在输入D之后要做一写调整D-1。

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
struct {
int relative;   //如果relative ==0,说明这个动物相对于根节点是同类，relative = 1,说明该动物相对于根节点是吃的关系，如果relative= 2，被吃的关系
int parent;
}animal[50010];
void MakeSet(int SizeOfSet)
{	//初始化并查集，将每个结点的根结点设置为自己
//相互之间关系确定的结点才放入一个集合里
//一句话都没有输入之前所有节点之间的关系都不确定，所以各自单独一个集合
//每个结合的根节点relative都是0，有利于合并时relative值的计算
for (int i = 0;i < SizeOfSet;i++)
{
animal[i].parent = i;
animal[i].relative = 0;
}
}
void Union(int RootOfX,int RootOfY,int NodeX,int NodeY,int D)
{	//此函数作用:1.将Y的根节点的根节点设置为X的根结点
//2.由于设置后RootOfY已经不再是根节点，所以要保证其kind相对于RootOfX的正确性
//在此函数里，D==0说明NodeX与NodeY同类，
//D==1说明NodeX吃NodeY，因此传参前要将D减一
//将Y所在树依附到X所在树上
animal[RootOfY].parent = RootOfX;
//更新RootOfY的kind，保证其kind相对于RootOfX的正确性
//原始公式为animal[NodeX].relative-(animal[NodeY].relative+amimal[RootOfY].relative)=D;
animal[RootOfY].relative = (-D+(animal[NodeX].relative-animal[NodeY].relative)+3)%3;
}
int Find(int NodeToFind)
{	//此函数作用：1找到NodeToFind所在集合，即找到其根节点
//2.查找的过程是一个递归过程，递归出口是遇到一个根节点为自身的结点，即当前集合的根节点
//然后递归返回的路径上依次将各个各个结点的根节点设置为此节点，并继续返回此根结点，这样就可以
//把集合中所有结点的根节点设置为同一个根结点，这叫做“路径压缩”，
//是为了使并查集稳定而做的一种改进，目的是避免并查集成为接近于链表的结构，因为并查集的优势体现在
//树的深度较浅，查找容易，此举可看作对并查集深度的控制。
//递归返回路径上，除了要做更新途径结点（按照距根从近到远的顺序）的根结点外，还要依次修正
//途径结点的relative。这是因为在Union操作中只是保证了直接和根节点相连的
//结点（即未作Union操作前的某一树的根）relative的正确性，其他节点kind的正确性就需要在这里修正
//从近到远进行修正恰好保证了每次修正都有理有据。
//每次修正都要依仗其原根节点relative的正确性，因为这是一个相对计算的关系
if(animal[NodeToFind].parent==NodeToFind)
return NodeToFind;
int temp = animal[NodeToFind].parent;
animal[NodeToFind].parent = Find(animal[NodeToFind].parent);
//更新NodeToFind结点kind的正确性，因为原来的kind是相对于0（根节点relative都为0），
//原来的根节点现在已经不是根节点了，所以只需要根据原根节点现有的kind值即可更新
animal[NodeToFind].relative = (animal[NodeToFind].relative+animal[temp].relative+3)%3;
return animal[NodeToFind].parent;
}
int main()
{
int n,k;
cin>>n>>k;
MakeSet(n);
int x,y,d;
int NumOfLies = 0;
while (k--)
{
//cin>>d>>x>>y;	//cin导致TLE
scanf("%d%d%d",&d,&x,&y);
//cin >> d >> x >> y;
if(x>n||y>n)
NumOfLies++;
else if(x==y&&d==2)
NumOfLies++;
else
{
int rootx = Find(x);
int rooty = Find(y);
if (rootx==rooty)
{
//如果两节点的根相等，说明根据以往结论，这两点的关系已经确定，可以开始判断
if(d==1&&animal[x].relative!=animal[y].relative)
NumOfLies++;
if(d==2&&(animal[x].relative-animal[y].relative+3)%3!=d-1)
NumOfLies++;
}
else
{
//x和y不在一个集合里，说明两者关系尚未确定，则将两者关系进行确定，
//即将两者所在集合进行合并操作Union，Union操作只保证了和根结点相连的结点kind
//的正确性，不要担心，由于并查集的特点（根节点表示法的树）所以无法从根向下找到
//子节点，因此子节点即使有错误也是安全的，到了需要访问（Find）的时候再修正也不迟
Union(rootx,rooty,x,y,d-1);	//别忘了d要减一才符合我们规定的含义

}
}
}
cout<<NumOfLies<<endl;
for(int i= 0; i< n; i++)
{
cout << i << ' '<< animal[i].parent<<' '<< animal[i].relative << endl;
}

}

下面对比较难理解的地方进行讲解：
1.

在main（）函数中
else
{
int rootx = Find(x);
int rooty = Find(y);
if (rootx==rooty)
{
if(d==1&&animal[x].relative!=animal[y].relative)
NumOfLies++;
if(d==2&&(animal[x].relative-animal[y].relative+3)%3!=d-1)
NumOfLies++;
}
else

Union(rootx,rooty,x,y,d-1);

}
}
}

首先通过find（）函数找出x和y的根节点rootx和rooty,
如果rootx和rooty相等，那么说明x和y的关系在原来语句的基础上是可以判断对错的，if(d==1&&animal[x].relative!=animal[y].relative) 如果输入的关系是d=1,说明这句话表明x和y是同类，而通过判断animal[x].relative与animal[y].relative是否是同类，如果animal[x].relative！=animal[y].relative说明在原来语句的基础上推出x和y不是同类，这样就与当前这个语句矛盾了，所以错误数++。
if(d==2&&(animal[x].relative-animal[y].relative+3)%3!=1)，如果输入关系d=2，说明x是吃y的，也就是说x相对于y的关系是1，那么怎么从以前语句中推出x和y的关系呢？是(animal[x].relative-animal[y].relative+3)%3，具体解释得通过向量关系来推导：













x相对于rootx的关系向量是animal[x].relative,y相对于rooty的关系向量是animal[y].relative，要求出x相对于y的关系，=》(animal[x].relative-animal[y].relative+3)%3,如果这个值和1不相等，也就是说以前的语句和当前语句矛盾，所以错误数++.
如果rootx和rooty不相等，说明x和y的关系在原有语句的基础上是不能确定的，于是我们就认为这个语句是正确的，于是调用Union(rootx,rooty,x,y,d-1);把x节点的树和y节点的树合并。注意这里为什么是d-1，是因为在前面解释了。

2.

在union()函数中做的修改：
void Union(int RootOfX,int RootOfY,int NodeX,int NodeY,int D)
{
animal[RootOfY].parent = RootOfX;
animal[RootOfY].relative = (-D+(animal[NodeX].relative-animal[NodeY].relative)+3)%3;
}

在union（）函数中，除了要对树rootx和树rooty进行合并，同时还要对rooty节点的relative做修改。
这里直接就是把rooty的parent指向了rootx.



虽然parent关系已经转了，但是relative关系还没有修改，注意这里只是修改了rooty相对于rootx的关系，而对于rooty的所有子节点相对于rootx的关系是没有修改的，这个修改时在find()函数中做的。那么怎么对rooty的relative关系进行修改呢？
animal[RootOfY].relative = (animal[NodeX].relative-animal[NodeY].relative-D+3)%3;
向量解释如下：



X相对于y的关系已经给了是D，y相对于rooty的关系是animal[y].relative,
x相对于rootx的关系是animal[x].relative，那么rooty相对于rootx的关系就是(animal[NodeX].relative-animal[NodeY].relative-D+3)%3;

3.

在find（）函数中做的修改：
int Find(int NodeToFind)
{
if(animal[NodeToFind].parent==NodeToFind)
return NodeToFind;
int temp = animal[NodeToFind].parent;
animal[NodeToFind].parent = Find(animal[NodeToFind].parent);
animal[NodeToFind].relative = (animal[NodeToFind].relative+animal[temp].relative)%3;
return animal[NodeToFind].parent;
}

在find函数中除了要返回nodeTofind的根节点，同时还要对在union（）中没有修改的节点的relative关系做修改.
首先用temp存储nodetoFind的父节点，之后递归调用Find()函数，对nodefoFind的父节点的relative做修改，也就是说find()完之后，nodetoFind父节点相对于根节点的关系已经确定了animal[tmp].relative，现在还知道nodetoFind相对于temp节点的关系animal[NodetoFind].relative。



于是可以计算nodetofind相对于root的关系：
Animal[nodetofind].relative = (animal[temp].relative +
animnal[nodetofind].relative)%3