C++博客-雪黛依梦-随笔分类-并查积

hdu 1233 kruskal + 并查积

雪黛依梦 — Thu, 26 Aug 2010 08:02:00 GMT

//用并查积和克鲁是卡尔算法实现查找最短边
//利用快排按边递增排列，每次从中选出最短边,同时将最短边的两个顶点并入到集合中
心得：利用并查积和 kruskal算法结合找最短路径可以使查找的效率更高
本题的关键是正确地设定好两个数组，一个是用于存放顶点边值的node1，另一个是用于并查积处理的node2，并且将这两个数组联系好
加入集合中的边都是构成最小生成树的边，所以每家一次sum 都要加上这两个顶点之间的距离

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

struct node1           //用于存放顶点和边值
{
    int x;
    int y;
    int distance;
};
node1 edge[5010];     // n 个顶点的边无向图最多有  n * (n - 1) / 2 条边

struct node2          //并查积数组
{
    int parent;
    int height;
};
node2 village[100];

bool cmp ( const node1 &a, const node1 &b )
{
     return a.distance < b.distance;
}
//并查积初始化
void set ( int n )
{
     for ( int i = 1; i <= n; i++)
     {
         village[i].parent = i;
     }
}

//找根节点
int findfather (int a)
{
       while ( a != village[a].parent )     //理解while 树状结构：找到最终的跟节点
             a = village[a].parent;
             return a;
}

//合并到同一集合
void merge (int a, int b)      //注意参数：要合并两个节点的根
{
     if ( village[a].height == village[b].height )
     {
          village[b].parent = a;
          village[a].height ++;
     }

     //小树合并到大树
     else if ( village[a].height > village[b].height )
     {
          village[b].parent = a;
     }
     else
     village[a].parent = b;
}

int main ()
{
     int n, k;
     int x, y, d;
     int a, b;
     while ( scanf ("%d", &n ) != EOF && n )
     {
           set ( n );
           memset ( edge, 0, sizeof (edge) );

           //输入处理
           k = n * ( n - 1 ) / 2;
           for ( int i = 0; i < k; i ++ )
           {
               scanf ( "%d %d %d", &x, &y, &d );
               edge[i].x = x;
               edge[i].y = y;
               edge[i].distance = d;
           }
           //排序
           sort ( edge, edge + k, cmp );

           //从已排好的序列中选出最短边同时利用并查积构建图
           int sum = 0;
           for ( int i = 0; i < k; i++ )
           {
               a = findfather ( edge[i].x );
               b = findfather ( edge[i].y );

               if ( a != b )
               {
                    merge ( a, b );
                    sum += edge[i].distance;
               }
           }
           printf ( "%d\n", sum );
     }
     //system ("pause");
     return 0;
}

雪黛依梦 2010-08-26 16:02 发表评论

hdu 1272

雪黛依梦 — Thu, 26 Aug 2010 02:41:00 GMT

//分析解决方案很明显的一个用并查积解决的问题：如果只用一个根肯定满足要求，遍历数组即可
//如果某两个要合并的节点同根肯定会构成回路，不满足要求

这里用sign 标记是否出现了同根，分两种情况处理即可，也WA 了几次，因为复制粘贴把那个求minn 和 maxn 弄错了
还有就是没处理一组输入的时候一定要避免上一组输入的影响，那就是初始化
其他的就是套用并查积的模板就可以了

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

struct node
{
   int parent;
   int weight;
};
node maze[100001];
int visit[100001];  //是集合中的元素都被标记

int findfather ( int i )
{
    while ( i != maze[i].parent )
          i = maze[i].parent;
          return i;
}

void merge ( int a, int b )
{
     if ( maze[a].weight == maze[b].weight )
     {
          maze[b].parent = a;
          maze[a].weight = b;
     }

     else if ( maze[a].weight > maze[b].weight )
          maze[b].parent = a;
     else
         maze[a].parent = b;
}

int main ()
{
    int a, b, a1, b1, sign;
    while ( scanf ("%d %d", &a, &b) != EOF )
    {
          memset (visit , 0, sizeof (visit));
          int maxn = 0;
          int minn = 1000000;

          //并查积算法的初始化
          for ( int i = 1; i < 100001; i ++ )
          {
           maze[i].parent = i;
           maze[i].weight = 1;
          }

          if ( a == -1 && b == -1 )
          break;
          if ( a == 0 && b == 0 )
          {
               printf ("Yes\n");
               continue;
          }

          sign = 0;
          do {
              if ( a < minn )     minn = a;           //找到输入的所有数据中最小的和最大的便于减小最后数组遍历时的复杂度
              if ( b < minn )     minn = b;
              if ( a > maxn )     maxn = a;
              if ( b > maxn )     maxn = b;
              visit[a] = visit[b] = 1;

              a1 = findfather (a);
              b1 = findfather (b);

              if ( a1 == b1 )   //节点同根
              {
                   sign = -1;
              }
              else
                  merge (a1, b1);

              scanf ("%d %d", &a, &b);

              if ( a== 0 && b == 0)
              break;
          }while (1);

          if ( sign == -1 )
          {
               printf ("No");
          }

          //遍历并查积看有几个根节点
          if ( sign == 0 )
          {
               for (int i = minn; i <= maxn; i ++)
               {
                   if ( visit[i] && maze[i].parent == i )
                   sign ++;
               }

               if (sign == 1)
               printf ("Yes\n");
               else
               printf ("No\n");
          }
    }
     //system ("pause");
     return 0;
}

雪黛依梦 2010-08-26 10:41 发表评论

hdu 1232

雪黛依梦 — Wed, 25 Aug 2010 14:48:00 GMT

这可是第一个并查积的题目哦！
先从问题的简单做法入手，构造出原始模型。

如果原始模型是对于集合之间合并处理问题，那么就可以使用并查集使得程序变得高效。

并查集的路径压缩只有在元素之间的特性存在递推关系时才可以使用。

关键是要理解那两个调用的函数，以及用树结构处理时要注意的问题：
1.合并的时候要注意是将高度较小的树合并到高度较大的树，所以小树的parent指向大树根节点
2.一定要理解一点就是合并两个节点实际上是合并他们的根节点，所以一定要找到节点，找到时候理解好也就是为什么findfather中为什么要用while的原因了

//此题运用并查积：就是将所有的村庄放到一个集合中
#include
#include
using namespace std;

struct node
{
   int parent;
   int height;
};

node village[1000];

//找根节点
int findfather (int a)
{
       while ( a != village[a].parent )     //理解while 树状结构：找到最终的跟节点
             a = village[a].parent;
             return a;
}

//合并到同一集合
void merge (int a, int b)      //注意参数：要合并两个节点的根
{
     if ( village[a].height == village[b].height )
     {
          village[b].parent = a;
          village[a].height ++;
     }

     //小树合并到大树
     else if ( village[a].height > village[b].height )
     {
          village[b].parent = a;
     }
     else
     village[a].parent = b;
}

int main ()
{
    int n, m;
    while ( scanf ("%d", &n) != EOF && n)
    {
          for (int i = 1; i <= n; i ++)        //根据并查积的算法，先将数组初始化，设定本身为一个独立的集合，并且高度都是 1
          {
              village[i].parent = i;
              village[i].height = 1;
          }

          scanf ("%d", &m);
          int a, b;
          int a1, b1;
          for (int i = 0; i < m; i ++)
          {
              scanf ("%d %d", &a, &b);     //找出要并入集合的元素的根，如果根节点相同则不并入同一个集合，反之，则并入到同一个集合

              a1 = findfather (a);
              b1 = findfather (b);

              if ( a1 != b1 )           //当根节点不同时合并跟节点
              merge (a1, b1);
          }

          //最后遍历并查积数组看看一共有几个不同的集合
          int sum = -1;
          for (int i = 1; i <= n; i ++)
          {
              if ( i == village[i].parent )
               sum ++;
          }
          printf ("%d\n", sum);
    }

     //system ("pause");
     return 0;
}

雪黛依梦 2010-08-25 22:48 发表评论