最小生成树
1.基本概念
1.定义:
(1)在给定一个无向图中求一棵树T
(2)使得这棵树拥有图G的所有顶点,边都是来自图G的边
(3)并且满足边权之和最小
2.性质:
(1)因为是树,所以边数=顶点数-1
(2)对给定的图G,其最小生成树可以不唯一,但边权之和一定是唯一的
(3)根节点可以是这棵树上的任意一个结点
2.最小生成树的求法
(1)prim算法
特点:类似于Dijkstra算法,只是在求解最短距离时,用集合S代替了起点s
伪代码:
Prim(G,d[]){
初始化;
for(循环n次){
u = 使d[u]最小的还未访问过的顶点的标号;
记u已被访问;
for(从u出发能到达的所有顶点v){
if(v从未访问&&以u为中介点使得v与集合S的最短距离d[v]更优){
将G[u][v]赋值给v与集合S的最短距离d[v];
}
}
}
}
邻接矩阵版:
const INF = 1000000000;
int n,G[MAXV][MAXV];
int d[MAXV];//顶点和集合S的最短距离
bool vis[MAXV] = {false};
int prim(){//默认0号为根节点,函数返回最小生成树的边权之和
//初始化
fill(d,d+MAXV,INF)
d[0] = 0;
int ans = 0;//存放最小生成树的边权之和
for(int i=0;i<n;i++){
int u = -1,MIN = INF;
for(int j=0;j<n;j++){
if(vis[j]==false&&d[j]<MIN){
u = j;
MIN = d[j];
}
}
//找不到小于INF的d[u],则剩下的顶点和集合S不连通
if(u==-1) return;
vis[u] = true;
ans += d[u]; //将与集合S距离最小的边加入最小生成树
//更新d[v]
for(int v=0;v<n;v++){
if(G[u][v]!=INF&&vis[v]==false&&G[u][v]<d[v]){
d[v] = G[u][v];
}
}
}
return ans;
}
邻接表版:
struct Node{
int v,dis;
};
vector<Node> Adj[MAXV];
int n;
int d[MAXV];
bool vis[MAXV] = {false};
int prim(){
//初始化
fill(d,d+MAXV,INF);
d[0] = 0;
int ans = 0;
for(int i=0;i<n;i++){
int u = -1,MIN = INF;
for(int j=0;j<n;j++){
if(vis[j]==false&&d[j]<MIN){
u = j;
MIN = d[j];
}
}
//找不到小于INF的d[u],则剩下的顶点和集合S不连通
if(u == -1) return;
vis[u] = true;
ans += d[u];
for(int j=0;j<Adj[u].size();j++){
int v = Adj[u][j].v;
if(vis[v]==false&&Adj[u][j].dis<d[v]){
d[v] = Adj[u][j].dis;
}
}
}
return ans;
}
(2)kruskal算法
伪代码:
int kruskal(){
令最小生成树的边权之和为ans,最小生成树的当前边数为Num_Edge;
将所有边按边权从小到大排序;
for(从小到大枚举所有边){
if(当前测试边的两个端点在不同的连通块中){
将该测试边加入最小生成树中;
ans += 测试边的边权;
最小生成树的当前边数Num_Edge+1
当边数Num_Edge等于顶点数-1时结束循环;
}
}
return ans;
}
问题:
1.如何判断测试边的两个端点是否再不同的连通块中
2.如何将测试边加入最小生成树
解决:
使用并查集,查找功能解决第一个问题,合并功能解决第二个问题
实现:
int father[N];//并查集数组
int findFather(int x){//并查集查询函数
if(father[x] = x){
return x;
}
else return findFather(father[x]);
}
struct edge{
int u,v;//边的两个端点
int cost;//边权
}E[MAXE];
bool cmp(edge a,edge b){
return a.cost<b.cost;
}
//n表示顶点个数,m表示图的边数,函数返回最小生成树的边权之和
int kruskal(int n,int m){
int ans = 0,Num_Edge = 0;
for(int i=1;i<=n;i++){//假设顶点范围为[1,n]
father[i] = i;
}
sort(E,E+m,cmp);//按边权大小从小到大排序
for(int i=0;i<m;i++){
int faU = findFather(E[i].u);
int faV = findFathre(E[i].v);
if(faU!=faV){//当前测试边的两个端点在不同的连通块中
father[faU] = faV;//将该测试边加入最小生成树中;
ans += E[i].cost;
Num_Edge++;
if(Num_Edge == n-1) break;
}
}
if(Num_Edge != n-1) return -1;//无法连通时返回-1
else return ans;
}