C++博客-ACM___________________________-随笔分类-ACM ( MST 最小生成树 )

PKU 1258 POJ 1258Agri-Net ( MST Kruskarl 并查集 ) ACM 1258 IN PKU

MiYu — Sat, 16 Oct 2010 08:30:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:

题目描述:

Agri-Net
Time Limit: 1000MSMemory Limit: 10000K
Total Submissions: 16557Accepted: 6745
Description
Farmer John has been elected mayor of his town! One of his campaign promises was to bring internet connectivity to all farms in the area. He needs your help, of course. 
Farmer John ordered a high speed connection for his farm and is going to share his connectivity with the other farmers. To minimize cost, he wants to lay the minimum amount of optical fiber to connect his farm to all the other farms. 
Given a list of how much fiber it takes to connect each pair of farms, you must find the minimum amount of fiber needed to connect them all together. Each farm must connect to some other farm such that a packet can flow from any one farm to any other farm. 
The distance between any two farms will not exceed 100,000. 
Input
The input includes several cases. For each case, the first line contains the number of farms, N (3 <= N <= 100). The following lines contain the N x N conectivity matrix, where each element shows the distance from on farm to another. Logically, they are N lines of N space-separated integers. Physically, they are limited in length to 80 characters, so some lines continue onto others. Of course, the diagonal will be 0, since the distance from farm i to itself is not interesting for this problem.
Output
For each case, output a single integer length that is the sum of the minimum length of fiber required to connect the entire set of farms.
Sample Input
4
0 4 9 21
4 0 8 17
9 8 0 16
21 17 16 0
Sample Output
28
题目分析 : 	MST 水题, 用KRUSKARL 或 PRIM 轻松能过.代码如下 :/*
Mail to   : miyubai@gamil.com
MyBlog    : http://baiyun.me
Link      : http://www.cnblogs.com/MiYu  || http://www.cppblog.com/MiYu
Author By : MiYu
Test      : 1
Complier  : g++ mingw32-3.4.2
Program   : Agri-Net
Doc Name  : PKU_1258
*/
//#pragma warning( disable:4789 )
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
const int MAX = 105;
int st[105];
int N, x, y, w;
struct vv {
       int x, y, val;
       void set ( int a, int b, int w ) { x=a,y=b,val=w; }

}v[10005];       
bool cmp ( const vv &a, const vv &b ) {
          return a.val < b.val;     
}
void creat () {
     for ( int i = 0; i <= N; ++ i )
          st[i] = i;     
}
int find ( int x ) {
    return x != st[x] ? find ( st[x] ) : x;    
}
void merge ( int x, int y ) {
     x = find ( x );
     y = find ( y );
     if ( x == y ) return;
     st[y] = x;     
}
int main ()
{
    while ( scanf ( "%d", &N )==1) {
           creat ();
           memset ( v, 0, sizeof ( v ) );
           int c = 0;
           for ( int i = 1; i <= N; ++ i ) {
                for ( int j = 1; j <= N; ++ j ) {
                     scanf ( "%d", &w );  
                     v[c++].set ( i,j,w );  
                }    
           }     
           sort ( v, v + c, cmp );
           int sum = 0;
           for ( int i = 0 ; i < c; ++ i ) {
                if ( find ( v[i].x ) != find ( v[i].y ) ) {
                    sum += v[i].val;  
                    merge ( v[i].x, v[i].y );
                }    
           }
           printf ( "%d\n", sum );
    }
    return 0;
}

MiYu 2010-10-16 16:30 发表评论

HDOJ 1879 HDU 1879 继续畅通工程 ACM 1879 IN HDU

MiYu — Tue, 10 Aug 2010 11:23:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=1879
题目描述:

继续畅通工程

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 4134 Accepted Submission(s): 1602

Problem Description
省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。现得到城镇道路统计表，表中列出了任意两城镇间修建道路的费用，以及该道路是否已经修通的状态。现请你编写程序，计算出全省畅通需要的最低成本。

Input
测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( 1< N < 100 )；随后的 N(N-1)/2 行对应村庄间道路的成本及修建状态，每行给4个正整数，分别是两个村庄的编号（从1编号到N），此两村庄间道路的成本，以及修建状态：1表示已建，0表示未建。

当N为0时输入结束。

Output
每个测试用例的输出占一行，输出全省畅通需要的最低成本。

Sample Input
3
1 2 1 0
1 3 2 0
2 3 4 0
3
1 2 1 0
1 3 2 0
2 3 4 1
3
1 2 1 0
1 3 2 1
2 3 4 1
0

Sample Output
3
1
0

题目分析:

这道题几乎是和 HDU1233 <---详情请点击.
几乎一模一样, 唯一不同的是: 在一些村庄之间已经有路存在了!!!!
这很好办. 我们只需要在输入的时候把已经存在的路提前加入并查集就行了.
接下来的就是 MST 了...........

代码如下:

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include <iostream>
#include <algorithm>
using namespace std;
typedef struct {
     int parent;
     int height;
}Tset;

typedef struct treeUFS{
       public:
              treeUFS(int n = 0):N(n+1) { set = new Tset[N];
                                          visited = new bool[N];
                                          for ( int i = 0; i != N; ++ i)
                                          set[i].parent = i,set[i].height = 1,visited[i] = false;
                                        }
              ~treeUFS(){ delete [] set; };
              int find ( int x ){  int r = x;  while ( r != set[r].parent ) r = set[r].parent;
                                   return r;
                                }
              void setVisit ( int x, int y ) { visited[x] = visited[y] = true; }
              bool getVisit ( int x ) { return visited[x]; }
              void Merge( int x,int y ){  x = find ( x );  y = find ( y );
                                           if ( x == y ) return;
                                           if ( set[x].height == set[y].height ){
                                                set[y].parent = x;
                                                set[x].height ++;
                                           }
                                           else if ( set[x].height < set[y].height ) {
                                                     set[x].parent = y;
                                                   }
                                           else{   set[y].parent = x;
                                               }
                                        }
       private:
              Tset *set;
              bool *visited;
              int N;
}treeUFS;
typedef struct edge {
       int v1,v2;
       int wei;
       int isBuild;
}EDGE;
EDGE edge[5005];
bool cmp ( EDGE A, EDGE B )
{
     return A.wei < B.wei;
}
int main ()
{
    int N;
    while ( scanf ( "%d",&N ) , N )
    {
            int n = N * ( N - 1 ) / 2;
            int v1,v2,b;
            memset ( edge, 0 , sizeof ( edge ) );
            treeUFS UFS ( N );
            for ( int i = 1; i <= n; ++ i )
            {
                  scanf ( "%d%d", &edge[i].v1,&edge[i].v2 );
                  scanf ( "%d%d", &edge[i].wei,&edge[i].isBuild );
                  if ( edge[i].isBuild == 1 )
                  {
                       UFS.Merge ( edge[i].v1, edge[i].v2 );
                       UFS.setVisit ( edge[i].v1, edge[i].v2 );
                  }
            }
            sort ( edge + 1, edge + n + 1, cmp );
            int sum = 0;
            for ( int i = 1; i <= n; ++ i )
            {
                  if ( ( !UFS.getVisit(edge[i].v1) || !UFS.getVisit(edge[i].v2) ) || UFS.find(edge[i].v1) != UFS.find(edge[i].v2) )
                  {
                        UFS.setVisit ( edge[i].v1, edge[i].v2 );
                        UFS.Merge ( edge[i].v1, edge[i].v2 );
                        sum += edge[i].wei;
                  }
            }
            printf ( "%d\n",sum );
    }
    return 0;
}

MiYu 2010-08-10 19:23 发表评论

HDOJ 1875 HDU 1875 畅通工程再续 ACM 1875 IN HDU

MiYu — Tue, 10 Aug 2010 11:11:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=1875
题目描述:

畅通工程再续

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 3822 Accepted Submission(s): 1076

Problem Description
相信大家都听说一个“百岛湖”的地方吧，百岛湖的居民生活在不同的小岛中，当他们想去其他的小岛时都要通过划小船来实现。现在政府决定大力发展百岛湖，发展首先要解决的问题当然是交通问题，政府决定实现百岛湖的全畅通！经过考察小组RPRush对百岛湖的情况充分了解后，决定在符合条件的小岛间建上桥，所谓符合条件，就是2个小岛之间的距离不能小于10米，也不能大于1000米。当然，为了节省资金，只要求实现任意2个小岛之间有路通即可。其中桥的价格为 100元/米。

Input
输入包括多组数据。输入首先包括一个整数T(T <= 200)，代表有T组数据。
每组数据首先是一个整数C(C <= 100),代表小岛的个数，接下来是C组坐标，代表每个小岛的坐标，这些坐标都是 0 <= x, y <= 1000的整数。

Output
每组输入数据输出一行，代表建桥的最小花费，结果保留一位小数。如果无法实现工程以达到全部畅通，输出”oh!”.

Sample Input
2
2
10 10
20 20
3
1 1
2 2
1000 1000

Sample Output
1414.2
oh!

题目分析:

因为边没有直接给出, 而是给的坐标点, 所以需要先计算每一个点到其他任意一点的距离, 并且记录下来. 如下 :
      for ( int i = 1; i <= N; ++ i )
           {
                 for ( int j = 1; j < i; ++ j )
                 {
                       edge[n].v1 = i;
                       edge[n].v2 = j;
                       edge[n].len = sqrt ( 0.0 + POW (LD[i].x - LD[j].x) + POW ( LD[i].y - LD[j].y ) );
                       n ++;
                 }
           }
注意红色部分!! 这样做很安全, 不加的话, G++可以通过,但在C++上会出现编译问题, 哥悲剧了2次 CE   T .T.

将边记录好以后, 就是正宗的最小生成树问题了.........直接KRUSKAL了. 这个我比较熟习, 呵呵.

代码如下:

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include <iostream>
#include <algorithm>
#include <cmath>
#define POW(x) ( (x) * (x) )
using namespace std;
typedef struct {
     int parent;
     int height;
}Tset;
typedef struct treeUFS{
       public:
              treeUFS(int n = 0):N(n+1) { set = new Tset[N];
                                          visited = new bool[N];
                                          for ( int i = 0; i != N; ++ i)
                                          set[i].parent = i,set[i].height = 1,visited[i] = false;
                                        }
              ~treeUFS(){ delete [] set; };
              int find ( int x ){  int r = x;  while ( r != set[r].parent ) r = set[r].parent;
                                   return r;
                                }
              void setVisit ( int x, int y ) { visited[x] = visited[y] = true; }
              bool getVisit ( int x ) { return visited[x]; }
              void Merge( int x,int y ){  x = find ( x );  y = find ( y );
                                           if ( x == y ) return;
                                           if ( set[x].height == set[y].height ){
                                                set[y].parent = x;
                                                set[x].height ++;
                                           }
                                           else if ( set[x].height < set[y].height ) {
                                                     set[x].parent = y;
                                                   }
                                           else{   set[y].parent = x;
                                               }
                                        }
              int getTreeCount (){ int nCount = 0; for ( int i = 1; i < N; ++ i ){
                                                         if ( find (i) == i ){
                                                              nCount ++;
                                                         }
                                                   }
                                   return nCount;
                                 }
       private:
              Tset *set;
              bool *visited;
              int N;
}treeUFS;
struct island{
       int x,y;
}LD[105];
typedef struct edge{
       int v1,v2;
       double len;
}EDGE;
EDGE edge[5050];
bool cmp ( EDGE A, EDGE B )
{
     return A.len < B.len;
}
int main ()
{
    int T;
    scanf ( "%d",&T );
    while ( T -- )
    {
           int N;
           scanf ( "%d",&N );
           treeUFS UFS ( N );
           for ( int i = 1; i <= N; ++ i )
           {
                 int x,y;
                 scanf ( "%d%d",&LD[i].x,&LD[i].y );
           }
           int n = 1;
           for ( int i = 1; i <= N; ++ i )
           {
                 for ( int j = 1; j < i; ++ j )
                 {
                       edge[n].v1 = i;
                       edge[n].v2 = j;
                       edge[n].len = sqrt ( 0.0 + POW (LD[i].x - LD[j].x) + POW ( LD[i].y - LD[j].y ) );
                       n ++;
                 }
           }
           double sum = 0.0;
           n = N * ( N - 1 ) / 2;
           sort ( edge + 1, edge + n + 1 , cmp );
           for ( int i = 1; i <= n; ++ i )
           {
                 if ( ( ( !UFS.getVisit(edge[i].v1) || !UFS.getVisit(edge[i].v2) ) || UFS.find(edge[i].v1) != UFS.find(edge[i].v2) ) && edge[i].len >=10 && edge[i].len <= 1000 )
                 {
                        UFS.setVisit ( edge[i].v1, edge[i].v2 );
                        UFS.Merge ( edge[i].v1, edge[i].v2 );
                        sum += edge[i].len;
                 }
           }
           int tCount = UFS.getTreeCount();
           if ( tCount != 1 )
           {
                 puts ( "oh!" );
                 continue;
           }
           printf ( "%.1lf\n",sum * 100 );
    }
    return 0;
}

MiYu 2010-08-10 19:11 发表评论

HDOJ 1233 HDU 1233 还是畅通工程 ACM 1233 IN HDU

MiYu — Tue, 10 Aug 2010 09:47:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=1233
题目描述:

还是畅通工程

Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 6742 Accepted Submission(s): 3087

Problem Description
某省调查乡村交通状况，得到的统计表中列出了任意两村庄间的距离。省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可），并要求铺设的公路总长度为最小。请计算最小的公路总长度。

Input
测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( < 100 )；随后的N(N-1)/2行对应村庄间的距离，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间的距离。为简单起见，村庄从1到N编号。
当N为0时，输入结束，该用例不被处理。

Output
对每个测试用例，在1行里输出最小的公路总长度。

Sample Input
3
1 2 1
1 3 2
2 3 4
4
1 2 1
1 3 4
1 4 1
2 3 3
2 4 2
3 4 5
0

Sample Output
3
5

题目分析:

最小生成树的问题. ---> 用 prim 或者 kruskal 算法求解, 我是用的kruskal算法.

按边的值做非降序排列, 然后从小到大对每条边一次判断, 如果2个顶点未全部访问或者不在同一个集合,那么加上这条边.直到最后一条边.
这道题目不用判断图的联通性, 直接输出最后已选则的边的总和即可.

代码如下:

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include <iostream>
#include <algorithm>
using namespace std;
typedef struct {
     int parent;
     int height;
}Tset;

typedef struct treeUFS{
       public:
              treeUFS(int n = 0):N(n+1) { set = new Tset[N];
                                          visited = new bool[N];
                                          for ( int i = 0; i != N; ++ i)
                                          set[i].parent = i,set[i].height = 1,visited[i] = false;
                                        }
              ~treeUFS(){ delete [] set; };
              int find ( int x ){  int r = x;  while ( r != set[r].parent ) r = set[r].parent;
                                   return r;
                                }
              void setVisit ( int x, int y ) { visited[x] = visited[y] = true; }
              bool getVisit ( int x ) { return visited[x]; }
              void Merge( int x,int y ){  x = find ( x );  y = find ( y );
                                           if ( x == y ) return;
                                           if ( set[x].height == set[y].height ){
                                                set[y].parent = x;
                                                set[x].height ++;
                                           }
                                           else if ( set[x].height < set[y].height ) {
                                                     set[x].parent = y;
                                                   }
                                           else{   set[y].parent = x;
                                               }
                                        }
       private:
              Tset *set;
              bool *visited;
              int N;
}treeUFS;
typedef struct edge {
       int v1,v2;
       int wei;
}EDGE;
EDGE edge[5005];
bool cmp ( EDGE A, EDGE B )
{
     return A.wei < B.wei;
}
int main ()
{
    int N;
    while ( scanf ( "%d",&N ) , N )
    {
            int n = N * ( N - 1 ) / 2;
            int v1,v2;
            memset ( edge, 0 , sizeof ( edge ) );
            treeUFS UFS ( N );
            for ( int i = 1; i <= n; ++ i )
            {
                  scanf ( "%d%d", &edge[i].v1,&edge[i].v2 );
                  scanf ( "%d", &edge[i].wei );
            }
            sort ( edge + 1, edge + n + 1, cmp );
            int sum = 0;
            for ( int i = 1; i <= n; ++ i )
            {
                  if ( ( !UFS.getVisit(edge[i].v1) || !UFS.getVisit(edge[i].v2) ) || UFS.find(edge[i].v1) != UFS.find(edge[i].v2) )
                  {
                        UFS.setVisit ( edge[i].v1, edge[i].v2 );
                        UFS.Merge ( edge[i].v1, edge[i].v2 );
                        sum += edge[i].wei;
                  }
            }
            printf ( "%d\n",sum );
    }
    return 0;
}

MiYu 2010-08-10 17:47 发表评论

HDOJ HDU 1863 畅通工程 ACM 1863 IN HDU

MiYu — Tue, 10 Aug 2010 09:22:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=1863
题目描述:

畅通工程

Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 5783 Accepted Submission(s): 2128

Problem Description
省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。经过调查评估，得到的统计表中列出了有可能建设公路的若干条道路的成本。现请你编写程序，计算出全省畅通需要的最低成本。

Input
测试输入包含若干测试用例。每个测试用例的第1行给出评估的道路条数 N、村庄数目M ( < 100 )；随后的 N
行对应村庄间道路的成本，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间道路的成本（也是正整数）。为简单起见，村庄从1到M编号。当N为0时，全部输入结束，相应的结果不要输出。

Output
对每个测试用例，在1行里输出全省畅通需要的最低成本。若统计数据不足以保证畅通，则输出“?”。

Sample Input
3 3
1 2 1
1 3 2
2 3 4
1 3
2 3 2
0 100

Sample Output
3
?

题目分析:

最小生成树的问题. ---> 用 prim 或者 kruskal 算法求解, 我是用的kruskal算法.

按边的值做非降序排列, 然后从小到大对每条边一次判断, 如果2个顶点未全部访问或者不在同一个集合,那么加上这条边.直到最后一条边.
最后判断一下图的连通性,如果不是连通的, 输出 ? , 否则输出已选则的边的总和.

做这个题的时候WA了6次, 一直找不到原因, 没办法的情况下,又把数据结构的书翻出来,把 kruskal
算法复习了一遍, 再次检查代码, 发现问题了, 算法的过程是一条边一条边的加入集合内, 我居然NC
的在输入的时候就全部加入集合了, 结构导致 kruskal 算法的断言没有起到作用. YM.

代码如下:

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include <iostream>
#include <algorithm>
using namespace std;
typedef struct {
     int parent;
     int height;
}Tset;

typedef struct treeUFS{
       public:
              treeUFS(int n = 0):N(n+1) { set = new Tset[N];
                                          visited = new bool[N];
                                          for ( int i = 0; i != N; ++ i)
                                          set[i].parent = i,set[i].height = 1,visited[i] = false;
                                        }
              ~treeUFS(){ delete [] set; };
              int find ( int x ){  int r = x;  while ( r != set[r].parent ) r = set[r].parent;
                                   return r;
                                }
              void init () { for ( int i = 0; i != N; ++ i)
                             set[i].parent = i,set[i].height = 1,visited[i] = false;  }
              void setVisit ( int x, int y ) { visited[x] = visited[y] = true; }
              bool getVisit ( int x ) { return visited[x]; }
              void Merge( int x,int y ){  x = find ( x );  y = find ( y );
                                           if ( x == y ) return;
                                           if ( set[x].height == set[y].height ){
                                                set[y].parent = x;
                                                set[x].height ++;
                                           }
                                           else if ( set[x].height < set[y].height ) {
                                                     set[x].parent = y;
                                                   }
                                           else{   set[y].parent = x;
                                               }
                                        }
              int getTreeCount (){ int nCount = 0; for ( int i = 1; i < N; ++ i ){
                                                         if ( find (i) == i ){
                                                              nCount ++;
                                                         }
                                                   }
                                   return nCount;
                                 }
       private:
              Tset *set;
              bool *visited;
              int N;
}treeUFS;
typedef struct edge {
       int v1;
       int v2;
       int wei;
}EDGE;
EDGE edge[10005];
bool cmp ( EDGE A, EDGE B )
{
     return A.wei < B.wei;
}
int main ()
{
    int N,M;
    while ( scanf ( "%d%d",&N,&M ) , N )
    {
            int v1,v2;
            if ( M == 0 )
            {
                 puts ( "?" );
                 continue;
            }
            memset ( edge, 0 , sizeof ( edge ) );
            treeUFS UFS ( M );
            for ( int i = 1; i <= N; ++ i )
            {
                  scanf ( "%d%d", &edge[i].v1,&edge[i].v2 );
                  scanf ( "%d", &edge[i].wei );
            }
            sort ( edge + 1, edge + N + 1, cmp );
            int sum = 0;
            for ( int i = 1; i <= N; ++ i )
            {
                  if ( ( !UFS.getVisit(edge[i].v1) || !UFS.getVisit(edge[i].v2) ) || UFS.find(edge[i].v1) != UFS.find(edge[i].v2) )
                  {
                        UFS.setVisit ( edge[i].v1, edge[i].v2 );
                        UFS.Merge ( edge[i].v1, edge[i].v2 );
                        sum += edge[i].wei;
                  }
            }
            int tCount = UFS.getTreeCount();
            if ( tCount != 1 )
            {
                 puts ( "?" );
                 continue;
            }
            printf ( "%d\n",sum );
    }
    return 0;
}

MiYu 2010-08-10 17:22 发表评论

HDOJ HDU 1272 小希的迷宫 ACM 1272 IN HDU

MiYu — Tue, 10 Aug 2010 06:11:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=1272
题目描述:

小希的迷宫

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 5006    Accepted Submission(s): 1427

Problem Description
上次Gardon的迷宫城堡小希玩了很久（见Problem B），现在她也想设计一个迷宫让Gardon来走。但是她设计迷宫的思路不一样，首先她认为所有的通道都应该是双向连通的，就是说如果有一个通道连通了房间A和B，那么既可以通过它从房间A走到房间B，也可以通过它从房间B走到房间A，为了提高难度，小希希望任意两个房间有且仅有一条路径可以相通（除非走了回头路）。小希现在把她的设计图给你，让你帮忙判断她的设计图是否符合她的设计思路。比如下面的例子，前两个是符合条件的，但是最后一个却有两种方法从5到达8。

Input
输入包含多组数据，每组数据是一个以0 0结尾的整数对列表，表示了一条通道连接的两个房间的编号。房间的编号至少为1，且不超过100000。每两组数据之间有一个空行。
整个文件以两个-1结尾。

Output
对于输入的每一组数据，输出仅包括一行。如果该迷宫符合小希的思路，那么输出"Yes"，否则输出"No"。

Sample Input
6 8  5 3  5 2  6 4
5 6  0 0

8 1  7 3  6 2  8 9  7 5
7 4  7 8  7 6  0 0

3 8  6 8  6 4
5 3  5 6  5 2  0 0

-1 -1

Sample Output
Yes
Yes
No

题目分析:

题目的要求是生成的图中没有环, 而且保证图是连通图.
判断很简单, 每一对输入的数据都被他们进行判断,看他们是不是在一个集合里面, 如果在一个集合里面, 那么说明这个图被连通,
也就是说这组数据是不符合要求的. 另外一个需要注意的判断就是, 当所有数据输入完成以后, 还要判断图的连通性, 保证整个图是连
通的, 如果集合的个数不为1,那就是说这个图有孤立点或多个集合, 那么这个图也不符合要求.
最后被输入数据的判断要注意一组数据只有 0 0 的情况.

代码如下:

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include <iostream>
using namespace std;
typedef struct {
     int parent;
     int height;
}Tset;
typedef class treeUFS{
       public:
              treeUFS(int n = 0):N(n+1) { set = new Tset[N];
                                          visited = new bool[N];
                                          for ( int i = 0; i != N; ++ i)
                                          set[i].parent = i,set[i].height = 1,visited[i] = false;
                                        }
              ~treeUFS(){ delete [] set; };
              int find ( int x ){  int r = x;  while ( r != set[r].parent ) r = set[r].parent;
                                   return r;
                                }
              void init () { for ( int i = 0; i != N; ++ i)
                             set[i].parent = i,set[i].height = 1,visited[i] = false;  }
              void setVisit ( int x, int y ) { visited[x] = visited[y] = true; }
              bool getVisit ( int x ) { return visited[x]; }
              void Merge( int x,int y ){  x = find ( x );  y = find ( y );
                                           if ( x == y ) return;
                                           if ( set[x].height == set[y].height ){
                                                set[y].parent = x;
                                                set[x].height ++;
                                           }
                                           else if ( set[x].height < set[y].height ) {
                                                     set[x].parent = y;
                                                   }
                                           else{
                                                     set[y].parent = x;
                                               }
                                        }
       private:
              Tset *set;
              bool *visited;
              int N;
}treeUFS;
int main ()
{
    int N,M;
    treeUFS UFS ( 100000 );
    while ( scanf ( "%d%d", &N, &M ) , N != -1 && M != -1 )
    {
            if ( M + N == 0 )
            {
                 printf ( "Yes\n" );
                 continue;
            }
            bool fail = false;
            UFS.init ();
            UFS.setVisit ( N,M );
            if ( UFS.find ( N ) == UFS.find ( M ) )
            {
                 fail = true;
            }
            UFS.Merge ( N, M );
            while ( scanf ( "%d%d", &N, &M ) , N + M )
            {
                 UFS.setVisit ( N,M );
                 if ( UFS.find ( N ) == UFS.find ( M ) )
                 {
                      fail = true;
                 }
                 UFS.Merge ( N, M );
            }
            int nCount = 0;
            for ( int i = 1; i != 100001; ++ i )
            {
                  if ( UFS.getVisit (i) && UFS.find(i) == i )
                  {
                       nCount ++;
                       if ( nCount > 1 )
                       {
                            break;
                       }
                  }
            }
            puts ( nCount == 1 && !fail ? "Yes" : "No" );
    }
    return 0;
}

MiYu 2010-08-10 14:11 发表评论

自己的并查集模板

MiYu — Tue, 10 Aug 2010 03:36:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

刚刚学习完并查集的基础知识.. 自己写了3个模板类 . 发上和大家分享下:

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include <iostream>
using namespace std;
typedef class arrUFS{
       public:
              arrUFS(int n = 0):N(n){ set = new int[n]; for ( int i = 0; i != N; ++ i) set[i] = i; };
              ~arrUFS(){ delete [] set; };
              int find ( int x ){ return set[x]; }
              void Merge1( int a,int b){   int i = min(set[a],set[b]);
                                           int j = max(set[a],set[b]);
                                           for ( int k=1; k<=N; k++) {
                                                 if (set[k] == j)
                                                 set[k] = i;
                                           }
                                       }
       private:
              int *set;
              int N;
}arrUFS; // 数组形式

//树形并查集, 路径压缩
typedef struct {
     int parent;
     int cnt;
}Tset;

typedef class treeUFS{
       public:
              treeUFS(int n = 0):N(n+2) { set = new Tset[N];
                                          for ( int i = 0; i != N; ++ i)
                                          set[i].parent = i,set[i].cnt = 1;
                                        }
              ~treeUFS(){ delete [] set; };
              int find ( int x ){ int r = x; while ( set[r].parent != r ) //循环结束，则找到根节点
                                                    r = set[r],parent;
                                             int i = x;
                                             while ( i != r) //本循环修改查找路径中所有节点
                                             {
                                                 int j = set[i].parent;
                                                 set[i].parent = r;
                                                 i = j;
                                             }
                                   return r;
                                }
              void Merge1( int x,int y ){  x = find ( x );  y = find ( y );
                                           if ( x == y ) return;
                                           if ( set[x].cnt > set[y].cnt ){
                                                set[y].parent = x;
                                                set[x].cnt += set[y].cnt;
                                           }
                                           else{
                                                   set[x].parent = y;
                                                   set[y].cnt += set[x].cnt;
                                               }
                                        }
       private:
              int *set;
              int N;
}treeUFS; // 树形式  路径压缩

//属性并查集, 带树深
typedef struct {
     int parent;
     int height;
}Tset;

typedef class treeUFS{
       public:
              treeUFS(int n = 0):N(n+2) { set = new Tset[N];
                                          visited = new bool[N];
                                          for ( int i = 0; i != N; ++ i)
                                          set[i].parent = i,set[i].height = 1,visited[i] = false;
                                        }
              ~treeUFS(){ delete [] set; };
              int find ( int x ){  int r = x;  while ( r != set[r].parent ) r = ser[r].parent;
                                   return r;
                                }
              void Merge1( int x,int y ){  x = find ( x );  y = find ( y );
                                           if ( x == y ) return;
                                           if ( set[x].height == set[y].height ){
                                                set[y].parent = x;
                                                set[x].height ++;
                                           }
                                           else if ( set[x].height < set[y].height ) {
                                                     set[x].parent = y;
                                                   }
                                           else{
                                                     set[y].parent = x;
                                               }
                                        }
       private:
              int *set;
              bool *visited;
              int N;
}treeUFS; // 树形式带树深

int main ()
{
    return 0;
}

MiYu 2010-08-10 11:36 发表评论

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 16557		Accepted: 6745

C++博客-ACM___________________________-随笔分类-ACM ( MST 最小生成树 )

PKU 1258 POJ 1258Agri-Net ( MST Kruskarl 并查集 ) ACM 1258 IN PKU

HDOJ 1879 HDU 1879 继续畅通工程 ACM 1879 IN HDU

HDOJ 1875 HDU 1875 畅通工程再续 ACM 1875 IN HDU

HDOJ 1233 HDU 1233 还是畅通工程 ACM 1233 IN HDU

HDOJ HDU 1863 畅通工程 ACM 1863 IN HDU

HDOJ HDU 1272 小希的迷宫 ACM 1272 IN HDU

自己的 并查集 模板

自己的并查集模板