poj 1182 食物链（并查集）解题报告（转）

  输入:动物个数n以及k句话,接着输入k行,每一行形式为:d x y,
   在输入时可以先判断题目所说的条件2和3,即:
      
1>若(x>n||y>n):即当前的话中x或y比n大,则假话数目num加1.
      
2>若(x==2&&x==y):即当前的话表示x吃x,则假话数目num加1.
  
而不属于这两种情况外的话语要利用并查集进行判断当前的话是否与此前已经说过的话相冲突.
   struct node
   {
      
int parent;                     //p[i].parent表示节点i的父节点
       int
relation;                   //p[i].relation表示节点i与其父节点(即p[i].parent)的关系
  
}p[50005];
   此处relation有三种取值(假设节点x的父节点为rootx,即p[x].parent=rootx)：
  
p[x].relation=0   ……》表示节点x与其父节点rootx的关系为同类
   p[x].relation=1  
……》表示节点x的父亲节点rootx吃节点x,即节点x被吃
   p[x].relation=2  
……》表示节点x吃它的父亲节点rootx,即节点x吃
  
   初始化函数为:void init_set(int
n)
               {
                   int i;
                  
for(i=1;i<=n;i++)
                   {
                      
p[i].parent=i;            //初始时集合编号就设置为自身
                      
p[i].relation=0;       
//因为p[i].parent=i,即节点i的父亲节点就是自身,所以此时节点i与其父亲节点的关系为同类(即p[i].relation=0)
                  
}
               }

   下面为并查集的两个重要操作:查找和合并.
  
在查找时因为节点不仅有父亲节点域,而且还有表示节点与其父亲节点关系的域,查找过程中对父亲节点域的处理和平常的处理一样,即在查找过程中同时实现路径压缩,但正是由于路径压缩,使得表示节点与其父亲节点的关系的域发生变化,所以相应查找节点表示其与父亲节点的关系的域也要发生变化(因为路径压缩之前节点x的父亲节点为rootx的话,那么在路径压缩之后节点x的父亲节点就变为了节点rootx的父亲节点rootxx,所以此时p[x].relation存储的是节点x与现在父亲节点rootxx的关系),此处可以画图理解一下:


   
很明显查找之前节点x的父亲节点为rootx,假设此时p[x].relation=1(即表示x的父亲节点rootx吃x)且p[rootx].relation=0(即表示rootx和其父亲节点rootxx是同类),由这两个关系可以推出rootxx吃x,而合并以后节点x的父亲节点为rootxx(实现了路径压缩),且节点x的父亲节点rootxx吃x,即查找之后p[x].relation=1,很容易的推出合并之后的p[x].relation=(p[rootx].relation+p[x].relation)%3.

    
在将元素x与y所在的集合合并时,假设元素x所在的集合编号为rootx,元素y所在的集合编号为rooty,合并时直接将集合rooty挂到集合rootx上,即p[rooty].parent=rootx,此时原来集合rooty中的根节点rooty的relation域也应随之发生变化,因为合并之前rooty的父亲节点就是其自身,故此时p[rooty].relation=0,而合并之后rooty的父亲节点为rootx,所以此时需判断rootx与rooty的关系,即更新p[rooty]的值,同理画图理解:
    
  
此时假设假设p[x].relation=0(即x与rootx的关系是同类),p[y].relation=1(即rooty吃y),则有:
       
1>输入d=1时,即输入的x和y是同类,则有上述关系可以推出rooty吃rootx,即p[rooty].relation=2;
       
2>输入d=2时,即输入的x吃y,则有上述关系可以推出rooty与rootx是同类(因为rooty吃y,x吃y,则rooty与x是同类,又rootx与x是同类),即p[rooty].relation=0;
  
当然,这只是一种可能,其它的可能情况和上面一样分析,则可以得知:p[rooty].relation=(3+(d-1)+p[x].relation-p[y].relation)%3.

  
当元素x与元素y在同一集合时,则不需要合并,因为此时x与y的父亲节点相同,可以分情况讨论:
       
1>d=1时,即x与y是同类时,此时要满足这要求,则必须满足p[x].relation=p[y].relation,这很容易推出来.
       
2>d=2时,即表示x吃y,此时要满足这要求,则必须满足(p[y].relation-p[x].relation+3)%3=1,如x和root是同类(即p[x].relation=0),此时要满足x吃y,则必须满足root吃y,即p[y].relation=1,可以像上面一样画图来帮助理解.
  
这道题目还有一点需要注意:输入的只有一组数据,若输入多组数据就显示Wrong Answer.

#include<iostream>
#include<cstdlib>
#include<string>
#include<algorithm>
using namespace std;

struct node
{
       int parent;
       int relation;
}p[50005];

void init_set(int n)                                                                      //初始化并查集
{
     int i;
     for(i=1;i<=n;i++)
     {
          p[i].parent=i;
          p[i].relation=0;
     }
}


int find(int x)                                                                       //查找元素x所在的集合
{
    int temp;
    if(x==p[x].parent)                                                            //x所在集合的根节点就是它自身
       return x;
    temp=p[x].parent;
    p[x].parent=find(temp);                                                   //路径压缩
    p[x].relation=(p[temp].relation+p[x].relation)%3;             //更新压缩后的关系域
    return p[x].parent;                                                           //返回所在的集合编号
}

void union_set(int x,int y,int rootx,int rooty,int d)     //将元素x与元素y所在的集合合并,rootx,rooty分别为x,y所在集合的根节点,d为题目所表示的关系(1和2）
{
     p[rooty].parent=rootx;                                                           //合并集合
     p[rooty].relation=(3+(d-1)+p[x].relation-p[y].relation)%3;    //更新原来集合rooty的关系域
}

int main()
{
    int n,k,x,y,d,i,px,py,num=0;
    scanf("%d%d",&n,&k);
    init_set(n);
    while(k--)
    {
                 scanf("%d%d%d",&d,&x,&y);
                 if(x>n||y>n)                                      //x或y大于n则就是假话
                   num++;
                 else if(d==2&&x==y)                       //此时表示x吃x
                   num++;
                 else
                 {
                     px=find(x);
                     py=find(y);
                     if(px!=py)                                  //x与y不在同一集合就进行合并
                        union_set(x,y,px,py,d);
                     else                                           //否则按上述所说进行处理
                     {
                         if(d==1&&p[x].relation!=p[y].relation)
                            num++;
                         else if(d==2&&(p[y].relation-p[x].relation+3)%3!=1)
                            num++;
                     }
                 }
    }
    printf("%d\n",num);
    system("pause");
    return 0;
}