并查集的应用

并查集的初级应用及进阶

一、精华

精华提炼1:

  内容:并查集就是树的孩子表示法的应用。

  解释:对于下图所示树,它的孩子表示法为:

       

                   

             belg[5]=2, belg[6]=2, belg[7]=2;

             belg[2]=1, belg[3]=1, belg[4]=1;

             belg[1]=1(也可以=-1,只要能够识别它是根就可以)

精华提炼2:

   内容:并查集的孩子父亲表示法中,每个节点与其父亲节点可以添加一个关系属性(必须具有可传递性)。

   解释:比如,节点表示一个人,关系属性为一个人的性别。我们先用上图来解释这个关系属性的应用,在后文具体展开。我们可以这样定义,如果节点i和其父节点j性别相同(belg[i]=j),则kind[i]=false, 反之,kind[i]=true,那么如果我们知道kind[5]=true,kind[2]=false,那么5和2的父节点1的关系为kind[5]^kind[2]=true,即他们性别不同。 

 

二、基础

基础1:集合表示

根据精华提炼1,我们把一颗树的节点集合看成以根节点命名的集合,那么上面的集合我们可以认为是集合1。

下图共有两个集合,分别为集合1,集合2。

 

            

基础2:元素关系

    如何判断元素关系呢?其实,我们只需找出元素对应的集合名称,然后判断名称是否相同即可。寻找集合名称代码如下:

int Find(int x)

{

while ( belg[x]!=x )

{

    x = belg[x];

}

 

return x;

}

例如:对于基础1中左图,有belg[5]=2,belg[2]=2。那么5属于集合2。

    现在我们已经解决了元素关系问题。

基础3:集合合并

集合如何合并呢?基础2中,我们已经可以找到元素对应集合的名称(即根节点标号),如果元素u、v(u、v不在同一集合)对应的集合名称为_u、_v,那么语句belg[_u]=_v什么意思呢?想到了吧?就是把集合_u与集合_v合并,并且以_v命名。

 

至此,通过基础部分我们知道了什么是并查集,通过精华提炼部分,我们知道了并查集的高级应用(精华提炼2)。

 

三、优化

虽然我们已经知道了基础的并查集,但是大家有没有想过简单用上面介绍的集合合并可能造成集合(树)的退化。比如对只有一个元素的集合1到集合n进行下述操作:把集合1合并到集合2,把集合2合并到集合3,…… 把集合n-1合并到集合n,那么生成一个含有n各元素的集合n,它的结构如下:

 

 

那么,每次判断n所属集合都要n次操作,即复杂度为O(n),这个耗费是不是必须的呢?其实不然。

优化1:路径压缩

对于上图退化的集合,它的表示是这样的:belg[n]=n-1, belg[n-1]=n-2, …… belg[2]=1, belg[1]=1;

既然上面元素都属于集合1,那么我们是不是可以这样做呢?belg[n]=1,belg[n-1]=1,……belg[2]=1,belg[1]=1;即把查找n所属集合时形成的路径上的点直接连到根节点上。可以的,因为这样操作只改变集合树的结构,并没有改变这个集合的元素。

关于路径压缩,可以在查找过程中实现,那么对于上述退化树,查找n第一次要n次操作,以后就只需一次操作。实现如下:

版本一:(递归)

int Find(int x)

{

  return x==belg[x]?x:(belg[x]=Find(belg[x]));

}

代码很短,递归次数多时,不建议使用。

版本二:(迭代)

int Find(int x)

{

  int _b, _x = x;

 

  while ( belg[_x]!=_x )

  {

     _x = belg[_x];     

  }

 

  while ( belg[x]!=x )

  {

     _b = belg[x];

     belg[x] = _x;

     x = _b;

  }

 

  return _x;

       }

       代码长点,但是少了递归过程,效率高点。

优化2:优化合并

     合理的安排合并方式,可以防止退化,例如对于上述退化的例子,我们把元素少的集合合并到元素多的集合上。即集合2合并到集合1,集合3合并到集合1,……集合n合并到集合1,那么产生的树结构为:

 

 

不过这个优化代价也很大的,因为要对开一个整型数组来记录集合元素个数,然后,再集合i和集合j合并时,通过判断集合中元素个数来实现合并:

int Union(int i,int j)

{

   if ( sum[i]>sum[j] )

   {

     belg[j] = i;

   }

   else

   {

     belg[i] = j;

   }

}

细心的读者,可能想到这个优化并不能完全避免集合退化,是的,所以我认为不必开辟数组浪费空间进行这个优化,完全可以随机法来由优化,比如:

int Union(int i,int j)

{

   if ( rand()&1 )

   {

     belg[j] = i;

   }

   else

   {

     belg[i] = j;

   }

}

通过随机值的奇偶性来决定怎么合并,平均效果是很好的。

   

上面详细讲了这么多理论性的东西,下面开始介绍应用:

四、应用

基础应用:

题目:

    有n个人(1..n),如果i和j是亲戚,j和k是亲戚,那么j和k也是亲戚,题目给定n各人的m对亲戚关系,然后提出q各问题,问你某两个人是不是亲戚。

解答:

    并查集简单应用,代码如下:

#include

usingnamespace std;

 

constint MAXN = 1010;

 

int belg[MAXN];

 

int main()

{

int i, u, v, n, m, q;

 

scanf("%d", &n);

for ( i=1; i<=n; belg[i]=i,++i );

 

scanf("%d", &m);

for ( i=1; i<=m; ++i )

{

    scanf("%d%d", &u, &v);

    u = Find(u); v = Find(v);

    if ( u!=v ) { Union(u,v); }

}

 

scanf("%d", &q);

for ( i=1; i<=q; ++i )

{

    scanf("%d%d", &u, &v);

    u = Find(u); v = Find(v);

    printf("%s/n", (u==v?"YES":"NO"));

}

 

return 0; 

}

其中Find函数和Union函数参见上面的介绍。

 

高级应用:

题目:(HDU1829

有n各小动物,它们只有异性之间才配对,同性之间不会配对。给定m对配对关系,问你是否能通过分配性别给n各小动物,使这m各配对关系成立,即不会出现同性之间配对。

解答:

这里我们使用在精华提炼二中提到的思路。

    首先,我们必须明确两点:1.这里的属于同一个集合的元素表示他们的关系已经确定,比如元素i和元素j属于同一个集合,那么他们要么同性,要么异性,关系时确定的。2.同一个集合的树表示中,节点i和它的父亲节点j关系存储在kind[i]中。

同时,我们约定,如果节点i和节点j性别相同,则关系为false,否则关系为true。根节点root满足kind[root]=false,因为自己跟自己性别肯定相同(当然不包括人妖了哈^-^)。

关系的运算我们可以通过异或(提示1)来实现,如果i和j关系为r1,i和k关系为r2,那么j和k关系为r1^r2。

上面的分析已经足够我们处理这个题目了。下面给出代码:

#include

usingnamespace std;

 

constint MAXN = 2010;

 

int  belg[MAXN];

bool kind[MAXN];

 

int Find(int x,bool &s);

 

int main()

{

    int  i, k, n, m;

    int  u, v, _u, _v, cas;

    bool flag, su, sv;

 

    scanf("%d", &cas);

 

    for ( k=1; k<=cas; ++k )

    {

        scanf("%d%d", &n, &m);

 

        for ( i=1; i<=n; ++i )

        {

            belg[i] = i;

            kind[i] =false;

        }

 

        for ( i=1,flag=true; i<=m; ++i )

        {

            scanf("%d%d", &u, &v);

 

            if ( flag )

            {

                _u = Find(u,su=false);

                _v = Find(v,sv=false);

 

                if ( _u==_v )

                {

                    flag = su^sv;

                }

                else

                {

                    belg[_u] = _v;

                    kind[_u] = !(su^sv);

                }

            }

        }

 

        printf("Scenario #%d:/n", k);

        if ( flag )

        {

            printf("No suspicious bugs found!/n/n");

        }

        else

        {

            printf("Suspicious bugs found!/n/n");

        }

    }

 

    return 0;

}

 

int Find(int x,bool &s)

{

    int h;

 

    if ( belg[x]==x )

    {

        h = x; s = false;   

    }

    else

    {

        h = Find(belg[x],s);

        belg[x] = h;

        s = kind[x]^s;

        kind[x] = s;

    }

 

    return h;

}

    由于上述Find函数使用了递归所以比较耗时(1609毫秒,132KB),可以改为如下的迭代形式(671毫秒,0KB):

int Find(int x,bool &s)

{

    int _x, h = x;

    bool s1, s2;

 

    while ( belg[h]!=h )

    {

        s = s^kind[h];

        h = belg[h];       

    }

 

    s1 = s;

    while ( belg[x]!=x )

    {

        _x = belg[x];

        belg[x] = h;

        s2 = kind[x];

        kind[x] = s1;

        s1 = s1^s2;

        x = _x;

    }

 

    return h;

}

 

提示1 . 异或:i和j异或就是:如果i和j相同则为false,否则为true,比如i=true,j=false,则i异或j为true。i=false,j=false,则i异或j为false。

你可能感兴趣的:(并查集的应用)