并查集扩展。。。。。

原创 2012年03月31日 16:35:12

  这篇文章转自http://blog.csdn.net/niushuai666/article/details/6981689

题目链接:http://poj.org/problem?id=1182

解题思路:

这道题是并查集题目中的经典。。。而且比普通并查集提高了一个档次,下面在基础并查集的前提上讲解并查集的真正用法。

基础回顾:

find()函数找根结点的两种写法如下:

第一种递归:

  1. int find(int x)  
  2. {  
  3.     return x == pre[x] ? x : find(pre[x]);  
  4. }  

第二种:

  1. int find(int x)  
  2. {  
  3.     int root, temp;  
  4.     root = x;  
  5.     while(root != pre[root])  
  6.         root = pre[root];  
  7.     while(x != root)  
  8.     {  
  9.         temp = pre[x];  
  10.         pre[temp] = root;  
  11.         x = temp;  
  12.     }  
  13.     return root;  
  14. }  

上面2种是最基本的查找操作。

下面我们通过这道题来讲解一下并查集的深层次应用。

输入:动物个数n以及k句话,接着输入k行,每一行形式为:d x y,在输入时可以先判断题目所说的条件2和3,即:
       1>若(x>n||y>n):即当前的话中x或y比n大,则假话数目sum加1.
       2>若(x==2&&x==y):即当前的话表示x吃x,则假话数目sum加1.

而不属于这两种情况外的话语要利用并查集进行判断当前的话是否与此前已经说过的话相冲突.

  1. struct node  
  2. {  
  3.     int parent;                     //p[i].parent表示节点i的父节点  
  4.     int relation;                   //p[i].relation表示节点i与其父节点(即p[i].parent)的关系  
  5. }p[50010];  

   此处relation有三种取值(假设节点x的父节点为rootx,即p[x].parent=rootx):
   p[x].relation=0   ……表示节点x与其父节点rootx的关系是:同类
   p[x].relation=1   ……表示节点x与其父节点rootx的关系是:被根结点吃
   p[x].relation=2   ……表示节点x与其父节点rootx的关系是:吃根结点
   
   初始化函数为:

  1. void init(int n)  
  2. {  
  3.     int i;  
  4.     for(i = 1;i <= n; ++i)  
  5.     {  
  6.         p[i].parent = i;            //初始时集合编号就设置为自身  
  7.         p[i].relation = 0;        //因为p[i].parent=i,即节点i的父亲节点就是自身,所以此时节点i与其父亲节点的关系为同类(即p[i].relation=0)  
  8.     }  
  9. }  

   下面详细讲解并查集的两个重要操作:查找和合并.

查找操作:
   在查找时因为节点不仅有父亲节点域,而且还有表示节点与其父亲节点的关系域,查找过程中对父亲节点域的处理和简单的并查集处理一样,即在查找过程中同时实现路径压缩,但正是由于路径压缩,使得表示节点与其父亲节点的关系域发生了变化,所以在路径压缩过程中节点和其对应的父节点的关系域发生了变化(因为路径压缩之前节点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。

合并操作:

     在将元素x与y所在的集合合并时,假设元素x所在的集合编号为rootx,元素y所在的集合编号为rooty,合并时直接将集合rooty挂到集合rootx上,即p[rooty].parent=rootx,此时原来集合rooty中的根节点rooty的关系域也应随之发生变化,因为合并之前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;
   当然,这只是一种可能,其它的可能情况和上面一样分析。

   当元素x与元素y在同一集合时,则不需要合并,因为此时x与y的父亲节点相同,可以分情况讨论:
        1>d=1时,即x与y是同类时,此时要满足这要求,则必须满足p[x].relation=p[y].relation,这很容易推出来.
        2>d=2时,即表示x吃y,此时要满足这要求,则也必须满足一定的条件,如x和root是同类(即p[x].relation=0),此时要满足x吃y,则必须满足root吃y,即p[y].relation=1,可以像上面一样画图来帮助理解.

关系域更新:

当然,这道题理解到这里思路已经基本明确了,剩下的就是如何实现,在实现过程中,我们发现,更新关系域是一个很头疼的操作,网上各种分析都有,但是都是直接给出个公式,至于怎么推出来的都是一笔带过,让我着实头疼了很久,经过不断的看discuss,终于明白了更新操作是通过什么来实现的。下面讲解一下

仔细再想想,rootx-x x-yy-rooty,是不是很像向量形式?于是我们可以大胆的从向量入手:

tx       ty

|          |

x   ~    y

对于集合里的任意两个元素xy而言,它们之间必定存在着某种联系,因为并查集中的元素均是有联系的(这点是并查集的实质,要深刻理解),否则也不会被合并到当前集合中。那么我们就把这2个元素之间的关系量转化为一个偏移量(大牛不愧为大牛!~YM)。

由上面可知:
x->y 偏移量0时 xy同类

x->y 偏移量1时 xy

x->y 偏移量2时 xy

有了这个假设,我们就可以在并查集中完成任意两个元素之间的关系转换了。

不妨继续假设,x的当前集合根节点rootxy的当前集合根节点rootyx->y偏移值为d-1(题中给出的询问已知条件)

(1)如果rootxrooty不相同,那么我们把rooty合并到rootx上,并且更新relation关系域的值(注意:p[i].relation表示i的根结点到i的偏移量!!!!(向量方向性一定不能搞错)

    此时 rootx->rooty = rootx->x + x->y + y->rooty,这一步就是大牛独创的向量思维模式

    上式进一步转化为:rootx->rooty = (relation[x]+d-1+3-relation[y])%3 = relation[rooty],(模3是保证偏移量取值始终在[0,2]间)

(2)如果rootxrooty相同(xy在已经在一个集合中,不需要合并操作了,根结点相同),那么我们就验证x->y之间的偏移量是否与题中给出的d-1一致

    此时 x->y = x->rootx + rootx->y

    上式进一步转化为:x->y = (3-relation[x]+relation[y])%3
    若一致则为真,否则为假。


分析到这里,这道题已经从思想过渡到实现了。剩下的就是一些细节问题,自己处理一下就好了。

PS:做完这题,就可以去秒了大部分基础的并查集了,嘿嘿大笑

代码如下:

  1. #include<iostream>  
  2. #include<cstdio>  
  3. #include<cstring>  
  4. #include<algorithm>  
  5. using namespace std;  
  6. #define N 50010  
  7.   
  8. struct node  
  9. {  
  10.     int pre;  
  11.     int relation;  
  12. };  
  13. node p[N];  
  14.   
  15. int find(int x) //查找根结点  
  16. {  
  17.     int temp;  
  18.     if(x == p[x].pre)  
  19.         return x;  
  20.     temp = p[x].pre; //路径压缩  
  21.     p[x].pre = find(temp);  
  22.     p[x].relation = (p[x].relation + p[temp].relation) % 3; //关系域更新  
  23.     return p[x].pre; //根结点  
  24. }  
  25.   
  26. int main()  
  27. {  
  28.     int n, k;  
  29.     int ope, a, b;  
  30.     int root1, root2;  
  31.     int sum = 0; //假话数量  
  32.     scanf("%d%d", &n, &k);  
  33.     for(int i = 1; i <= n; ++i) //初始化  
  34.     {  
  35.         p[i].pre = i;  
  36.         p[i].relation = 0;  
  37.     }  
  38.     for(int i = 1; i <= k; ++i)  
  39.     {  
  40.         scanf("%d%d%d", &ope, &a, &b);  
  41.         if(a > n || b > n) //条件2  
  42.         {  
  43.             sum++;  
  44.             continue;  
  45.         }  
  46.         if(ope == 2 && a == b) //条件3  
  47.         {  
  48.             sum++;  
  49.             continue;  
  50.         }  
  51.         root1 = find(a);  
  52.         root2 = find(b);  
  53.         if(root1 != root2) // 合并  
  54.         {  
  55.             p[root2].pre = root1;  
  56.             p[root2].relation = (3 + (ope - 1) +p[a].relation - p[b].relation) % 3;  
  57.         }  
  58.         else  
  59.         {  
  60.             if(ope == 1 && p[a].relation != p[b].relation)  
  61.             {  
  62.                 sum++;  
  63.                 continue;  
  64.             }  
  65.             if(ope == 2 && ((3 - p[a].relation + p[b].relation) % 3 != ope - 1))  
  66.             {  
  67.                 sum++;  
  68.                 continue;}  
  69.         }  
  70.     }  
  71.     printf("%d\n", sum);  
  72.     return 0;  
  73. }  


带全并查集(并查集拓展应用)

并查集是一种优秀的数据结构,能够支持快速的查找某元素所在的集合以及合并操作。最常见的并查集的实现方式是森林,通过记录所有结点或者部分结点(下面会看到)的父节点来记录森林。并查集的详细实现方式可以参考C...

POJ 1182 (经典食物链 /并查集扩展)

向量偏移——由“食物链”引发的总结 http://poj.org/problem?id=1182这道食物链题目是并查集的变型,很久以前做的一次是水过的,这次仔细地研究了这“食物链”,无非就是运用向量...

<(扩展域/加权)并查集>NOI 2001 食物链

可提交的传送门题目描述 Description动物王国中有三类动物 A,B,C,这三类动物的食物链构成了有趣的环形。A吃B,B吃C,C吃A。    现有N个动物,以1-N编号。每个动物都是A,B,...

【P2024】食物链 (扩展域并查集)

https://www.luogu.org/problem/show?pid=2024 题目描述动物王国中有三类动物 A,B,C,这三类动物的食物链构成了有趣的环形。A 吃 B,B吃 C,C 吃 A。...

并查集的分析及应用

并查集的分析及简单应用,个人理解并作记录之用。 ————凌...

并查集的应用

并查集的初级应用及进阶 一、精华 精华提炼1:   内容:并查集就是树的孩子表示法的应用。   解释:对于下图所示树,它的孩子表示法为:                              ...

并查集(Union-Find)算法介绍

本文主要介绍解决动态连通性一类问题的一种算法,使用到了一种叫做并查集的数据结构,称为Union-Find。 更多的信息可以参考Algorithms 一书的Section 1.5,实际上本文也就是...

并查集应用举例

首先还是回顾和总结一下关于并查集的几个关键点: 以树作为节点的组织结构,结构的形态很是否采取优化策略有很大关系,未进行优化的树结构可能会是“畸形”树(严重不平衡,头重脚轻,退化成链表等),按尺寸...

并查集 -- 学习详解

作者:Yx.Ac 出处:勇幸|Thinking (http://www.ahathinking.com)         昨天和今天学习了并查集和trie树,并练习了三道入门题目,理解...
  • JDPlus
  • JDPlus
  • 2014年02月19日 16:50
  • 3773

并查集的使用及其实现

并查集概述性质并查集算法(union_find sets)不支持分割一个集合,求连通子图、求最小生成树用法并查集是由一个数组pre[],和两个函数构成的,一个函数为find()函数,用于寻找前导点的,...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:并查集扩展。。。。。
举报原因:
原因补充:

(最多只允许输入30个字)