最近在整理图论的算法。并且做了一些基础的题来练习，现在做一个总结，然后准备进入下一类算法的复习。
算法这个东西，就是不要害怕去编，哪怕自己只是有一点点理解，有好多点的模糊， 找一道基础的题， 对应着有一种思路解答的，去学习代码，学习里面的思路，并且自己动手跟着敲一敲，慢慢的就会理解了。 不用想着一开始就能够很彻底的理解算法的细节上思想。 理解的时候，从它所要达到的目的去思考， 知道它是要做一个什么事情，这是第一步。后面慢慢的多去练，就会更加深刻的理解里面的思想了，包括细节部分， 也会一点一点也清晰了。
感觉最近也总是提不起劲来做事情，果然是之前的大项目让自己疲惫了么，让自己消耗了太多脑细胞了咩。
噢哟哟， 想来这种情况在未来也可能是常态的， 我也得平时留心注意找一个能够让自己放松休息的方法， 劳逸结合， 这句话越来越觉得不错了。
古语真是古语，越品越有味道。
现在连最喜欢追的动漫，看起来都打不起精神来了。 学习底层的干劲也不是很强。 不过也是正常吧， 大脑在过度的使用之后，开始疲于思考， 或者说懒于思考了。
总之，这个月， 好好休息吧。
=================================================================================================================================
扯了一堆题外话，只在抒发一下自己的心情，很多事情要说出来才好。
首先总结两个图论算法，都是最小生成树算法。
prim算法：看一张图，简单明了。
prim算法的核心思想，就是以集合为中心，向外扩散。
分为两个集合, set1{}正在处理的最小生成树点 ,set2{}待处理的最小生成树点
每次从set2{}中寻找一个与该集合相邻接的，权值最小的点，加入set1{}， 直到set2{}中的点找完了。
下面是一个模板算法：算法是参考牙签大哥的。
模板使用说明：MAXN为定义的顶点最大可达数，n为图的大小，图以邻接表的形式存放在map中，调用prim函数后，最小需要花费的值为ret。
#define MAXN 101
int n, ret;
int map[MAXN][MAXN];
void prim()
{
int closet[MAXN];//set1{}集合的标记，标记为1的，表示加入到set1{}集合中
int dist[MAXN];//set2{}集合中的点到set1{}集合的最小距离，随着点的加入，要逐步更新
int i, j;
for ( i=0; i<n; i++)
{
closet[i] = 0;//将点都初始化为在set2{}集合中
dist[i] = map[0][i];//将以0号点v1为初始点，最小距离，设置为到v1的距离
}
closet[0] = 1;
int u, min;
for ( i=1; i<n; i++)//寻找剩下的n-2个点的最小距离的边
{
min = 100001;
for ( j=1; j<n; j++)//寻找一个set2{}集合的，到set1{}集合距离最小的点。
{
if ( ! closet[j] && dist[j] < min && dist[j] > 0)
{
u = j;
min = dist[j];
}
}
closet[u] = 1;//找到的点设置为set1{}集合
ret += min;//权值对应的增加
for ( j=1; j<n; j++)//依次更新各个点到set1{}集合的最小距离
{
if (! closet[j] && map[u][j] < dist[j] )
dist[j] = map[u][j];
}
}
}
Kruskal算法的核心，是以边的权值为出发点，从最小的权值边开始寻找，依次寻找边所依赖的两个点在不同的联通分量的点，直到最后构成n-1条边组成的最小生成树。
再上一个算法模板，
模板使用方法：vn表示图中结点个数，dis用邻接表的形式表示一幅图，dis[i][j]为0时表示i点和j点不连通，最后所需耗费的最小值存于sum中。
#include <stdio.h>
#include <queue>
using namespace std;
#define Maxv 100+5
typedef struct
{
int v1,v2,len;
}Node;//节点的结构体，边的两个点，和边的权值
bool operator > (Node a,Node b)//设置优先队列的排列条件
{
if( a.len > b.len )
return true;
return false;
}
int dis[Maxv][Maxv];//图的邻接表
int fa[Maxv];//对应点的父亲
int Getfa(int i)//寻找点i的父亲节点， 并且更新点i的父亲节点
{
if( fa[i] == i ) return i;
fa[i] = Getfa(fa[i]);
return fa[i];
}
int main()
{
int sum;
priority_queue< Node,vector<Node>,greater<Node> > Q; //返回最小数
int vn,i,j;
while( scanf( "%d" , &vn ) != EOF )
{
//输入图部分
for( i = 1 ; i <= vn ; i++ )
for( j = 1 ; j <= vn ; j++ )
scanf( "%d" , &dis[i][j] );
for( i = 1 ; i <= vn ; i++ ) fa[i] = i;
while( !Q.empty() ) Q.pop();//清空队列的点
//把每条边压入堆中
for( i = 1 ; i < vn ; i++ )
for( j = i+1 ; j <= vn ; j++ )
if( dis[i][j] )
{
Node e;
e.v1 = i , e.v2 = j , e.len = dis[i][j];
Q.push(e);
}
sum = 0;
while( Q.size() != 0 )//从最小边权值开始出发寻找，满足条件的边
{
Node e;
e = Q.top();//去除最小值
Q.pop();
if( Getfa(e.v1) != Getfa(e.v2) )//如果边的两个点的父亲不同，即属于不同的联通分量，就连接这两个点
{
sum += e.len;
fa[Getfa(e.v2)] = Getfa(e.v1);//v2的父亲的父亲 等于 v1的父亲，将v1,v2 连接起来了
}
}
printf( "%d\n" , sum ); //所需的最小值
}
return 0;
}
还使用了STL里面的一个非常方便的priority_queue。这里有它的详细使用方法，很好用的。
http://www.cnblogs.com/flyoung2008/articles/2136485.html
==================================================================================================================================
接下来，就是我练习的题目的总结，解答仅供参考。
stage1:
畅通工程（http://acm.hdu.edu.cn/showproblem.php?pid=1232）
这道题目我在开始的时候考虑少了一种情况。
我在开始是这样考虑的。
设置两个集合set1（满足联通的点）, set2(待分析的点)。
对于每对输入的点，如果两个点，有一个以上的点在set1中，则不用增加边将它们联通；
如果两个点都不在set1中，则需要增加一个边将它们联通。
这个逻辑表面上看起来没有错，其实有一个错误：后面扫描边的时候，有两个点都在set1中，但是这两个点是在处理上述第二种情况的时候我自己加进去的，那么就会多出一条边。就是因为这个原因，我总是无法AC。后来多块CSDN的朋友，才得以解决。感谢CSDN的朋友！
下面上代码：
#include <stdio.h>
int city[1005];//用来记录点所在的集合，或者说联通分量
int main()
{
int n,m;
int count=0;
while(1)
{
scanf("%d",&n);
if( n == 0)
{
break;
}
scanf("%d",&m);
int i,a,b,temp,j;
int unionIndex = 0;
int unionNum = 0;
for ( i=1; i<=n; i++ ) city[i] = -1;//2、城市编号从1开始
for ( i=0; i<m; i++ )
{
scanf("%d%d",&a,&b);
if ( a == b ) continue;
if ( (city[a] == -1) && ( city[b] == -1 ) )
{
city[a] = unionIndex;
city[b] = unionIndex++;
unionNum++;
}
else if ( (city[a] != -1) && ( city[b] == -1 ) )
{
city[b] = city[a];
}
else if ( (city[a] == -1) && ( city[b] != -1 ) )
{
city[a] = city[b];
}
//缺少对后期连接了两个集合的判断， 可以减少独立集合数
//1、缺少对 输入的两个数本身就是一个集合的判断，这时不需要减少独立集合数
else if ( (city[a] != city[b]) && (city[a] != -1) && ( city[b] != -1 ) )
{
//对所有等于a集合标志的元素，归并成b集合标志的元素
temp = city[a];
for ( j=1; j<=n; j++ )//this range !!
if ( city[j] == temp ) city[j] = city[b];
unionNum--;
}
}
for ( i=1; i<=n; i++ )
{
if ( city[i] == -1 ) unionNum++;
}
//
//到目录为止一共有unionNum个联通集，则至少需要再添unionNum-1条路
printf( "%d\n", unionNum-1 );
}
return 0;
}但随着到后期，相信很多算法，会内化成为我自然而然使用的设计方法。
stage2:
还是畅通工程（http://acm.hdu.edu.cn/showproblem.php?pid=1233）这里我依旧是从自己的考虑出发，凭借脑海中模糊的prim算法思想，构造出的代码，一次就ac成功了。仅供参考。
#include <stdio.h>
int map[102][102];//city start from 1
int rea_len=0;
int city[102];
int main()
{
int n,j,i;
while(scanf("%d",&n) && n)
{
int x,y,dis;
//init the map
for(i=1 ; i < 102 ; i++)
for(j=1 ; j<102 ; j++)
{
map[i][j] = 9999;
}
for(i=1 ; i<102 ;i++)
{
city[i]= 0;
}
rea_len=n;
city[1] = 1;
//input the city distance data
for(i=0 ; i< n*(n-1)/2 ; i++)
{
scanf("%d%d%d",&x,&y,&dis);
map[x][y] = dis;
map[y][x] = dis;
}
int k;
int sum=0;
while( --rea_len )
{
int min=9999;
for(i=1 ; i<=n; i++)
{
if( city[i] == 1)
for(j=1 ; j<=n ;j++)
{
if(i!=j && city[j] == 0 && (map[i][j] < min || map[j][i] < min) )
{
min = map[i][j];
k = j;
}
}
}
city[k] = 1;
sum += min;
}
printf("%d\n",sum);
}
return 0;
}stage3:
畅通工程（http://acm.hdu.edu.cn/showproblem.php?pid=1863）后面的解题，主要依靠Getfa函数，并且随着解题的深入，对于Getfa函数的理解也越来越深刻了。靠着Getfa函数，后面解题势如破竹。这个东西真是好用。
#include <stdio.h>
#include <queue>
using namespace std;
#define MAX 102
typedef struct
{
int x,y,cost;
}NODE;
bool operator > (NODE a, NODE b)
{
if( a.cost > b.cost ) return true;
return false;
}
//记录i点的父亲的值
int fa[MAX];
//寻找并且更新i点的最终父亲
int getfa(int i)
{
if( fa[i] == i) return i;
fa[i] = getfa( fa[i] );
return fa[i];
}
int main()
{
int n,m,i,j,sum;
priority_queue< NODE , vector<NODE>, greater<NODE> > Q;
while( scanf("%d",&n) && n)
{
while( !Q.empty() ) Q.pop();
sum=0;
scanf("%d",&m);
int x,y,cost;
NODE e;
while( n-- )
{
scanf("%d%d%d",&x,&y,&cost);
e.x = x;
e.y= y;
e.cost = cost;
Q.push(e);
}
for(i=1 ; i<=m ;i++) fa[i] = i;
while( Q.size() )
{
e = Q.top();
Q.pop();
if( getfa(e.x) != getfa(e.y) )
{
sum += e.cost;
fa[getfa(e.x)] = getfa(e.y);
}
}
for(i=1 ; i<m ;i++)
{
if( getfa(i) != getfa(i+1) )
{
printf("?\n");
break;
}
}
if( i == m)
{
printf("%d\n",sum);
}
}
return 0;
}stage4:
欧拉回路（http://acm.hdu.edu.cn/showproblem.php?pid=1878）
这道基础题关键就是要分析出欧拉回路的特点：
判断一个图是否存在欧拉回路的充要条件是：1）每个点的度数为偶数，2）图是连通的
#include <stdio.h>
int fa[1003];
int count[1003];
int getfa(int i)
{
if(fa[i] == i) return i;
fa[i] = getfa( fa[i] );
return fa[i];
}
bool isOK(int n)//判断联通，以及节点度数是否为偶数
{
int i;
for(i=1 ;i<n ; i++)
{
if( getfa(i) != getfa(i+1) || count[i] %2 != 0)
return false;
}
if( count[i]%2 != 0) return false;
return true;
}
int main()
{
int n,m,i;
while( scanf("%d",&n) && n)
{
scanf("%d",&m);
int x,y;
for(i=1 ; i<=n ; i++)
{
fa[i] = i;
count[i] = 0;
}
while(m--)
{
scanf("%d%d",&x,&y);
count[x]++;
count[y]++;
// 将x父亲的父亲指定为 y 的父亲。从根源处将两点联通。
// x--x1--x2 y--y1--y2 , x2--y2
fa[ getfa(x)] = getfa(y);
}
if( isOK(n) )
printf("1\n");
else
printf("0\n");
}
return 0;
}继续畅通工程（http://acm.hdu.edu.cn/showproblem.php?pid=1879）
//1.operator 操作数的使用方法
//2.priority_queue 的定义方法
#include <stdio.h>
#include <queue>
using namespace std;
typedef struct
{
int x,y,cost;
}NODE;
int fa[103];
int getfa(int i)
{
if( fa[i] == i) return i;
fa[i] = getfa( fa[i]);
return fa[i];
}
bool operator > (NODE a, NODE b)
{
if(a.cost > b.cost ) return true;
return false;
}
int main()
{
int n,i,sum;
priority_queue< NODE, vector<NODE>, greater<NODE> > Q;
while( scanf("%d", &n) && n)
{
while( !Q.empty() ) Q.pop();
for(i=1 ;i<=n; i++)
{
fa[i] = i;
}
sum=0;
int x,y,cost,isbuild;
NODE e;
for(i=1 ;i<= n*(n-1)/2 ; i++)
{
scanf("%d%d%d%d",&x ,&y, &cost, &isbuild);
if( isbuild == 1)
{
fa[ getfa(x)] = getfa(y);
continue;
}
e.x = x;
e.y = y;
e.cost = cost;
Q.push(e);
}
//由于没有一个比较有效的实时判断图是否已经连通的函数
//因此，将队列中所有的点都判断一遍，以做到在连通的情况下
//计算出最小成本
while( Q.size() )
{
e = Q.top();
Q.pop();
if( getfa(e.x) != getfa(e.y) )
{
fa[ getfa(e.x)] = getfa(e.y);
sum += e.cost;
}
}
printf("%d\n",sum);
}
return 0;
}感谢牙签，感谢wxspll。如果有什么问题，欢迎讨论。
扫一扫
380
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
