数据结构与算法（13）—— 最小生成树

最新推荐文章于 2023-05-24 23:40:41 发布

Will Jay

最新推荐文章于 2023-05-24 23:40:41 发布

阅读量294

点赞数

分类专栏：数据结构与算法文章标签：算法数据结构

本文链接：https://blog.youkuaiyun.com/weixin_45418001/article/details/106450889

版权

数据结构与算法专栏收录该内容

22 篇文章

订阅专栏

最小生成树
- 普利姆（Prlm）
  - ①从图中找第一个起始顶点v0，作为生成树的第一个顶点，然后从这个顶点到其他顶点的所有边中选一条权值最小的边。然后把这条边的另一个顶点v和这条边加入到生成树中。
  - ②对剩下的其他所有顶点，分别检查这些顶点与顶点v的权值是否比这些顶点在lowcost数组中对应的权值小，如果更小，则用较小的权值更新lowcost数组。
  - ③从更新后的lowcost数组中继续挑选权值最小而且不在生成树中的边，然后加入到生成树。
  - ④反复执行②③直到所有所有顶点都加入到生成树中。
  - 概要:
    - 双重循环，外层循环次数为n-1，内层并列的两个循环次数都是n。故普利姆算法时间复杂度为O(n2)
      而且时间复杂度只和n有关，所以适合稠密图
- 克鲁斯卡尔（Kruskal）
  - 将图中边按照权值从小到大排列，然后从最小的边开始扫描，设置一个边的集合来记录，如果该边并入不构成回路的话，则将该边并入当前生成树。直到所有的边都检测完为止。
    - 概要: 克鲁斯卡尔算法操作分为对边的权值排序部分和一个单重for循环，它们是并列关系，由于排序耗费时间大于单重循环，所以克鲁斯卡尔算法的主要时间耗费在排序上。排序和图中边的数量有关系，所以适合稀疏图

贪心算法

什么是 “贪”：每一步都是最好的
什么是 “好”：权重最小的边
需要约束：
　* 只能用图里有的边
　* 只能正好用掉 |V|-1 条边
　* 不能有回路
Prim 算法

void Prim(){
    MST = {s};  // parent[s] = -1
    while(1){
        V = 未收录顶点中dist最小者;   // dist[V] = E<V,W> 或 正无穷
        if ( 这样的V不存在 )
            break;
        dist[V] = 0;  // 将V收录进MST
        for ( V 的每个邻接点 W )
            if ( dist[W]!= 0)
                if ( E<V,W> < dist[w] ){
                    dist[W] = E<V,W>;
                    parent[W] = V;
                }
    }
    if ( MST 中收的顶点不到|V|个)
        Error ( "图不连通" );
}

时间复杂度：T = O(|V|^2 ) —— 稠密图合算

#include<iostream>
#include<vector>
#define INF 100000
#define MaxVertex 105
typedef int Vertex; 
int G[MaxVertex][MaxVertex];
int parent[MaxVertex];   // 并查集 
int dist[MaxVertex]; // 距离 
int Nv;    // 结点 
int Ne;    // 边 
int sum;  // 权重和 
using namespace std; 
vector<Vertex> MST;  // 最小生成树 

// 初始化图信息 
void build(){
	Vertex v1,v2;
	int w;
	cin>>Nv>>Ne;
	for(int i=1;i<=Nv;i++){
		for(int j=1;j<=Nv;j++)
			G[i][j] = 0;  // 初始化图 
		dist[i] = INF;   // 初始化距离
		parent[i] = -1;  // 初始化并查集 
	}
	// 初始化点
	for(int i=0;i<Ne;i++){
		cin>>v1>>v2>>w;
		G[v1][v2] = w;
		G[v2][v1] = w;
	}
}

// Prim算法前的初始化 
void IniPrim(Vertex s){
	dist[s] = 0;
	MST.push_back(s);
	for(Vertex i =1;i<=Nv;i++)
		if(G[s][i]){
			dist[i] = G[s][i];
			parent[i] = s;
		} 
}

// 查找未收录中dist最小的点 
Vertex FindMin(){
	int min = INF;
	Vertex xb = -1;
	for(Vertex i=1;i<=Nv;i++)
		if(dist[i] && dist[i] < min){ 
			min = dist[i];
			xb = i;
		}
	return xb;
}

void output(){
	cout<<"被收录顺序："<<endl; 
	for(Vertex i=1;i<=Nv;i++)
		cout<<MST[i]<<" ";
	cout<<"权重和为："<<sum<<endl; 
	cout<<"该生成树为："<<endl; 
	for(Vertex i=1;i<=Nv;i++)
		cout<<parent[i]<<" ";
}

void Prim(Vertex s){
	IniPrim(s);
	while(1){
		Vertex v = FindMin();
		if(v == -1)
			break;
		sum += dist[v];
		dist[v] = 0;
		MST.push_back(v);
		for(Vertex w=1;w<=Nv;w++)
			if(G[v][w] && dist[w])
				if(G[v][w] < dist[w]){
					dist[w] = G[v][w];
					parent[w] = v;![在这里插入图片描述](https://img-blog.csdnimg.cn/20200531084630442.gif)
				}
	}
}


int main(){
	build();
	Prim(1);
	output();
	return 0;
}

Kruskal 算法

在这里插入图片描述

void Kruskal ( Graph G ){
    MST = { };
    while ( MST 中不到|V|-1条边 &&  E中还有边 ) {
        从 E 中取一条权重最小的边 E<V,W>;    // 最小堆
        将 E<V,W> 从 E 中删除;
        if ( E<V,W> 不在 MST 中构成回路 )  // 并查集
            将 E<V,W> 加入MST;
        else
            彻底无视 E<V,W>;
    }
    if ( MST 中不到|V|-1条边 )
        Error("图不连通");
}

时间复杂度：T = O(|E|log|E|) —— 稀疏图合算

#include<iostream>
#include<string>
#include<vector>
#include<queue>
#define INF 100000
#define MaxVertex 105
typedef int Vertex; 
int G[MaxVertex][MaxVertex];
int parent[MaxVertex];   // 并查集最小生成树 
int Nv;    // 结点 
int Ne;    // 边 
int sum;  // 权重和 
using namespace std; 
struct Node{
	Vertex v1;
	Vertex v2;
	int weight; // 权重 
	// 重载运算符成最大堆 
	bool operator < (const Node &a) const
	{
		return weight>a.weight;
	}
};
vector<Node> MST;  // 最小生成树 
priority_queue<Node> q;   // 最小堆 

// 初始化图信息 
void build(){
	Vertex v1,v2;
	int w;
	cin>>Nv>>Ne;
	for(int i=1;i<=Nv;i++){
		for(int j=1;j<=Nv;j++)
			G[i][j] = 0;  // 初始化图
		parent[i] = -1;
	}
	// 初始化点
	for(int i=0;i<Ne;i++){
		cin>>v1>>v2>>w;
		struct Node tmpE;
		tmpE.v1 = v1;
		tmpE.v2 = v2;
		tmpE.weight = w;
		q.push(tmpE); 
	}
}

//  路径压缩查找 
int Find(int x){
	if(parent[x] < 0)
		return x;
	else
		return parent[x] = Find(parent[x]);
} 

//  按秩归并 
void Union(int x1,int x2){
    x1 = Find(x1);
    x2 = Find(x2);
	if(parent[x1] < parent[x2]){
		parent[x1] += parent[x2];
		parent[x2] = x1;
	}else{
		parent[x2] += parent[x1];
		parent[x1] = x2;
	}
} 

void Kruskal(){
	// 最小生成树的边不到 Nv-1 条且还有边 
	while(MST.size()!= Nv-1 && !q.empty()){
		Node E = q.top();  // 从最小堆取出一条权重最小的边
		q.pop(); // 出队这条边 
		if(Find(E.v1) != Find(E.v2)){  // 检测两条边是否在同一集合 
			sum += E.weight; 
			Union(E.v1,E.v2);     // 并起来 
			MST.push_back(E);
		}
	}
	
} 


void output(){
	cout<<"被收录顺序："<<endl; 
	for(Vertex i=0;i<Nv;i++)
		cout<<MST[i].weight<<" ";
	cout<<"权重和为："<<sum<<endl; 
	for(Vertex i=1;i<=Nv;i++)
		cout<<parent[i]<<" ";
	cout<<endl;
}


int main(){
	build();
	Kruskal();
	output();
	return 0;
}