图结构练习——最小生成树
Time Limit: 1000ms Memory limit: 65536K
题目描述
有n个城市,其中有些城市之间可以修建公路,修建不同的公路费用是不同的。现在我们想知道,最少花多少钱修公路可以将所有的城市连在一起,使在任意一城市出发,可以到达其他任意的城市。
输入
输入包含多组数据,格式如下。
第一行包括两个整数n m,代表城市个数和可以修建的公路个数。(n <= 100, m <=10000)
剩下m行每行3个正整数a b c,代表城市a 和城市b之间可以修建一条公路,代价为c。
输出
每组输出占一行,仅输出最小花费。
示例输入
3 2 1 2 1 1 3 1 1 0
示例输出
2 0
提示
这里要用到最小生成树的知识点 :
一个有 n 个结点的
连通图
的生成树是原图的极小连通子图,且包含原图中的所有 n 个结点,并且有保持图连通的最少的边。
最小生成树可以用
kruskal
(克鲁斯卡尔)算法或
prim
(普里姆)算法求出。
Prim算法:(普里姆算法是以某顶点为起点,逐步找各顶点上最小权值的边来构建最小生成树。)
图的存贮结构采用邻接矩阵.此方法是按各个顶点连通的步骤进行,需要用一个顶点集合,开始为空集,以后将以连通的顶点陆续加入到集合中,全部顶点加入集合后就得到所需的最小生成树 .
思路:设图G顶点集合为U,首先任意选择图G中的一点作为起始点a,将该点加入集合V,再从集合U-V中找到另一点b使得点b到V中任意一点的权值最小,此时将b点也加入集合V;以此类推,现在的集合V={a,b},再从集合U-V中找到另一点c使得点c到V中任意一点的权值最小,此时将c点加入集合V,直至所有顶点全部被加入V,此时就构建出了一颗MST。因为有N个顶点,所以该MST就有N-1条边,每一次向集合V中加入一个点,就意味着找到一条MST的边。
#include<iostream>
#include<limits.h>
#define Max INT_MAX
using namespace std;
int gp[110][110];
int Prim(int n)
{
int lowcost[110]; //表示终点的边的最小权值
int adjvex[110]; //标记数组,判断节点是否遍历
int sum=0; //统计总路线
int i,j,k,min,minid;
for( i=1; i<=n; i++) //从节点1开始
{
lowcost[i]=gp[1][i];
adjvex[i]=0;
}
adjvex[1]=1;
for(i=1; i<n; i++)
{
min=Max;
minid=0;
for(j=2; j<=n; j++)
{
if(!adjvex[j]&&lowcost[j]<min)
{
min=lowcost[j];
minid=j; //存储当前最小值的下标
}
}
sum+=min;
adjvex[minid]=1;
for(j=2; j<=n; j++)
{
if(!adjvex[j]&&gp[minid][j]<lowcost[j])
{
lowcost[j]=gp[minid][j]; //更新lowcost数组
}
}
}
for(int i=1; i<=n; i++) //判断是否连通
{
if(!adjvex[i])
{
sum=-1;
break;
}
}
return sum;
}
int main()
{
int n,m;
while(cin>>n>>m)
{
for(int i=1; i<=n; i++) // 赋初值
for(int j=1; j<=n; j++)
if(i==j)
gp[i][j]=0;
else
gp[i][j]=Max;
for(int i=0; i<m; i++)
{
int a,b,d;
cin>>a>>b>>d;
if(d<gp[a][b]) //若路径相同,取最小值
{
gp[a][b]=d;
gp[b][a]=d;
}
}
int s=Prim(n);
cout<<s<<endl;
}
return 0;
}
#include<iostream>
#include<limits.h>
#define Max INT_MAX
using namespace std;
int gp[110][110];
int Prim(int n)
{
int lowcost[110]; //表示终点的边的最小权值
int sum=0; //统计总路线
int i,j,k,min,minid;
for( i=2; i<=n; i++) //从节点1开始
{
lowcost[i]=gp[1][i];
}
lowcost[1]=-1;
for(i=1; i<n; i++)
{
min=Max;
minid=-1;
for(j=2; j<=n; j++)
{
if(lowcost[j]!=-1&&lowcost[j]<min)
{
min=lowcost[j];
minid=j; //存储当前最小值的下标
}
}
sum+=min;
lowcost[minid]=-1;
for(j=2; j<=n; j++)
{
if(lowcost[j]!=-1&&gp[minid][j]<lowcost[j])
{
lowcost[j]=gp[minid][j]; //更新lowcost数组
}
}
}
for(int i=1; i<=n; i++) //判断是否连通
{
if(!lowcost[i])
{
sum=-1;
break;
}
}
return sum;
}
int main()
{
int n,m;
while(cin>>n>>m)
{
for(int i=1; i<=n; i++) // 赋初值
for(int j=1; j<=n; j++)
if(i==j)
gp[i][j]=0;
else
gp[i][j]=Max;
for(int i=0; i<m; i++)
{
int a,b,d;
cin>>a>>b>>d;
if(d<gp[a][b]) //若路径相同,取最小值
{
gp[a][b]=d;
gp[b][a]=d;
}
}
int s=Prim(n);
cout<<s<<endl;
}
return 0;
}
Krusal算法:(克鲁斯卡尔算法是直接以边为目标去构建。)
图的存贮结构采用边集数组,且权值相等的边在数组中排列次序可以是任意的.该方法对于边相对比较多的不是很实用,浪费时间.
思路:设无向连通网为G=(V, E),令G的最小生成树为T=(U, TE),其初态为U=V,TE={ },然后,按照边的权值由小到大的顺序,考察G的边集E中的各条边。若被考察的边的两个顶点属于T的两个不同的连通分量(并查集),则将此边作为最小生成树的边加入到T中,同时把两个连通分量连接为一个连通分量;若被考察边的两个顶点属于同一个连通分量,则舍去此边,以免造成回路,如此下去,当T中的连通分量个数为1时,此连通分量便为G的一棵最小生成树。
#include<iostream>
#include<queue>
#include<algorithm>
using namespace std;
struct node
{
int b,e,w;
};
bool cmp(node x,node y) //比较函数,按权值升序排列
{
return x.w<y.w;
}
int Find(int pre[],int k) //查找函数:查找连通分量顶点
{
while(k!=pre[k])
k=pre[k];
return k;
}
void Kruskal(node g[],int m,int n)
{
int i,sum=0,cnt=0;
int pre[100];
for( i=1; i<=n; i++)
pre[i]=i;
for( i=0; i<m; i++)
{
int x=Find(pre,g[i].b);
int y=Find(pre,g[i].e);
if(x!=y) //不相等,说明不在一个连通分量
{
pre[x]=y; //将y加入x的连通分量
sum+=g[i].w; //计算路径
// cout<<g[i].b<<" "<<g[i].e<<" "<<g[i].w<<endl;
}
}
cout <<sum<<endl;
}
int main()
{
int n,m;
node g[10000];
while(cin>>n>>m)
{
for(int i=0; i<m; i++) //建立边集数组
{
int a,b,d;
cin>>a>>b>>d;
g[i].b=a;
g[i].e=b;
g[i].w=d;
}
sort(g,g+m,cmp);
Kruskal(g,m,n);
}
return 0;
}