算法记录——图算法（最小生成树、最短路径、拓扑排序）

最新推荐文章于 2023-02-02 08:00:00 发布
最新推荐文章于 2023-02-02 08:00:00 发布
阅读量368 收藏
点赞数 2
分类专栏： 学习笔记 文章标签： 算法 图论 bellman–ford algorithm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a15651035561/article/details/108475604
版权

C++最小生成树、最短路径、拓扑排序算法实现

一、最小生成树算法

1. Prim最小生成树算法（扩展点）

#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<stack>
#include<vector>
#include<string>
#include<deque>
using namespace std;

struct Edge
{
	int head;
	int tail;
	int weight;
};

void readData(vector<vector<int>> & matrix)
{
	int n = 6;
	matrix.resize(n, vector<int>(n, INT_MAX));
	for(int i = 0; i < n; i++)
	{
		matrix[i][i] = 0;
	}
	matrix[0][1] = 2;
	matrix[1][0] = 2;
	matrix[0][2] = 5;
	matrix[2][0] = 5;
	matrix[0][3] = 4;
	matrix[3][0] = 4;
	matrix[1][2] = 4;
	matrix[2][1] = 4;
	matrix[1][4] = 5;
	matrix[4][1] = 5;
	matrix[2][3] = 6;
	matrix[3][2] = 6;
	matrix[2][4] = 3;
	matrix[4][2] = 3;
	matrix[2][5] = 4;
	matrix[5][2] = 4;
	matrix[3][5] = 7;
	matrix[5][3] = 7;
	matrix[4][5] = 1;
	matrix[5][4] = 1;
}


void printTree(vector<Edge>& tree)
{
	for(int i = 0; i < tree.size(); i++)
	{
		cout<<tree[i].head<<" ---> "<<tree[i].tail<<"(weight = "<<tree[i].weight<<")"<<endl;
	}
}

void prim(vector<vector<int>> &matrix, int s)
{
	int n = matrix.size();
	vector<int> minedge(n, 0);
	vector<int> pre(n, 0);
	vector<bool> visited(n, false);
	vector<Edge> tree;
	for(int i = 0; i < n; i++)
	{
		minedge[i] = matrix[s][i];
		pre[i] = s;
	}
	minedge[s] = 0;
	visited[s] = true;
	for(int i = 0; i < n-1; i++)
	{
		int k = 0;
		int minn = INT_MAX;
		for(int j = 0; j < n; j++)
		{
			if(!visited[j] && minn > minedge[j])
			{
				minn = minedge[j];
				k = j;
			}
		}
		Edge t;
		t.head = pre[k];
		t.tail = k;
		t.weight = minedge[k];
		tree.push_back(t);
		minedge[k] = 0;
		visited[k] = true;
		for(int j = 0; j < n; j++)
		{
			if(!visited[j] && matrix[k][j] < minedge[j])
			{
				minedge[j] = matrix[k][j];
				pre[j] = k;
			}
		}
	}
	printTree(tree);
}

int main ()
{
	vector<vector<int>> matrix;
	readData(matrix);
	prim(matrix, 0);
	return 0;
}

2. Kruskal最小生成树算法（扩展边）

#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<stack>
#include<vector>
#include<string>
#include<deque>
using namespace std;

struct Edge
{
	int head;
	int tail;
	int weight;
};

void readData(vector<vector<int>> & matrix)
{
	int n = 6;
	matrix.resize(n, vector<int>(n, INT_MAX));
	for(int i = 0; i < n; i++)
	{
		matrix[i][i] = 0;
	}
	matrix[0][1] = 2;
	matrix[1][0] = 2;
	matrix[0][2] = 5;
	matrix[2][0] = 5;
	matrix[0][3] = 4;
	matrix[3][0] = 4;
	matrix[1][2] = 4;
	matrix[2][1] = 4;
	matrix[1][4] = 5;
	matrix[4][1] = 5;
	matrix[2][3] = 6;
	matrix[3][2] = 6;
	matrix[2][4] = 3;
	matrix[4][2] = 3;
	matrix[2][5] = 4;
	matrix[5][2] = 4;
	matrix[3][5] = 7;
	matrix[5][3] = 7;
	matrix[4][5] = 1;
	matrix[5][4] = 1;
}

void printTree(vector<Edge>& tree)
{
	for(int i = 0; i < tree.size(); i++)
	{
		cout<<tree[i].head<<" ---> "<<tree[i].tail<<"(weight = "<<tree[i].weight<<")"<<endl;
	}
}

void getEdges(vector<vector<int>> &matrix, vector<Edge>& edges)
{
	int n = matrix.size();
	for(int i = 0; i < n; i++)
	{
		for(int j = i+1; j < n; j++)
		{
			if(matrix[i][j] != INT_MAX && matrix[i][j] != 0)
			{
				Edge e;
				e.head = i;
				e.tail = j;
				e.weight = matrix[i][j];
				edges.push_back(e);
			}
		}
	}
}

struct cmp
{
	bool operator()(const Edge& a, const Edge& b)
	{
		if(a.weight < b.weight)
			return true;
		return false;
	}
};

void kruskal(vector<vector<int>> &matrix)
{
	vector<Edge> tree;
	vector<Edge> edges;
	getEdges(matrix, edges);
	sort(edges.begin(), edges.end(), cmp());
	int n = matrix.size();
	vector<int> components(n, 0);
	for(int i = 0; i < n; i++)
		components[i] = i;
	int k = 0;
	int j = 0;
	while(k < n-1)
	{
		int h1 = edges[k].head;
		int t1 = edges[k].tail;
		int h2 = components[h1];
		int t2 = components[t1];
		if(h2 != t2)
		{
			Edge t;
			t.head = h1;
			t.tail = t1;
			t.weight = edges[k].weight;
			tree.push_back(t);
			k++;
			for(int i = 0; i < n; i++)
			{
				if(components[i] == t2)
					components[i] = h2;
			}
		}
		j++;
	}
	printTree(tree);
}

int main ()
{
	vector<vector<int>> matrix;
	readData(matrix);
	kruskal(matrix);
	return 0;
}

二、最短路径算法

1. Dijkstra单源最短路径算法（正权边）

#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<stack>
#include<vector>
#include<string>
#include<deque>
using namespace std;

void readData2(vector<vector<int>> & matrix)
{
	int n = 5;
	matrix.resize(n, vector<int>(n, INT_MAX));
	for(int i = 0; i < n; i++)
	{
		matrix[i][i] = 0;
	}
	matrix[0][1] = 10;
	matrix[0][3] = 30;
	matrix[0][4] = 100;
	matrix[1][2] = 50;
	matrix[2][4] = 10;
	matrix[3][2] = 20;
	matrix[3][4] = 60;
}

void printPath(vector<int>& path, vector<int>& dist)
{ 
	int n = path.size();
	for(int i = n-1; i >= 1; i--)
	{
		vector<int> t;
		int k = i;
		while(k != -1)
		{
			t.insert(t.begin(),k);
			k = path[k];
		}
		cout << t[0];
		for(int j = 1; j < t.size(); j++)
			cout << " ---> " << t[j];
		cout<<"( dist = "<<dist[i]<<" )"<<endl;
	}
}

void dijkstra(vector<vector<int>> &matrix, int s)
{
	int n = matrix.size();
	vector<int> dist(n, INT_MAX);
	vector<int> visited(n, false);
	vector<int> path(n, -1);
	for(int i = 0; i < n; i++)
	{
		dist[i] = matrix[s][i];
		if(dist[i] == INT_MAX || i == s)
			path[i] = -1;
		else
			path[i] = s;
		
	}
	dist[s] = 0;
	path[s] = -1;
	visited[s] = true;
	for(int i = 0; i < n-1; i++)
	{
		int minn = INT_MAX;
		int pos = -1;
		for(int j = 0; j < n; j++)
		{
			if(!visited[j] && minn > dist[j])
			{
				minn = dist[j];
				pos = j;
			}
		}
		visited[pos] = true;
		for(int j = 0; j < n; j++)
		{
			if(!visited[j] && matrix[pos][j] != INT_MAX && dist[j] > dist[pos] + matrix[pos][j])
			{
				path[j] = pos;
				dist[j] = dist[pos] + matrix[pos][j]; 
			}
		}
	}
	printPath(path,dist);
}

int main ()
{
	vector<vector<int>> matrix;
	readData2(matrix);
	dijkstra(matrix, 0);
	return 0;
}

2. BellmanFord单源最短路径算法（可判定负环）

#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<stack>
#include<vector>
#include<string>
#include<deque>
using namespace std;

struct Edge
{
	int head;
	int tail;
	int weight;
};

void readData2(vector<vector<int>> & matrix)
{
	int n = 5;
	matrix.resize(n, vector<int>(n, INT_MAX));
	for(int i = 0; i < n; i++)
	{
		matrix[i][i] = 0;
	}
	matrix[0][1] = 10;
	matrix[0][3] = 30;
	matrix[0][4] = 100;
	matrix[1][2] = 50;
	matrix[2][4] = 10;
	matrix[3][2] = 20;
	matrix[3][4] = -60;  //[4][3]即有负环
}

void printPath(vector<int>& path, vector<int>& dist)
{ 
	int n = path.size();
	for(int i = n-1; i >= 1; i--)
	{
		vector<int> t;
		int k = i;
		while(k != -1)
		{
			t.insert(t.begin(),k);
			k = path[k];
		}
		cout << t[0];
		for(int j = 1; j < t.size(); j++)
			cout << " ---> " << t[j];
		cout<<"( dist = "<<dist[i]<<" )"<<endl;
	}
}

void getEdges2(vector<vector<int>> &matrix, vector<Edge>& edges)
{
	int n = matrix.size();
	for(int i = 0; i < n; i++)
	{
		for(int j = 0; j < n; j++)
		{
			if(matrix[i][j] != INT_MAX && matrix[i][j] != 0)
			{
				Edge e;
				e.head = i;
				e.tail = j;
				e.weight = matrix[i][j];
				edges.push_back(e);
			}
		}
	}
}

void bellmanFord(vector<vector<int>> &matrix, int s)
{
	int n = matrix.size();
	vector<Edge> edge;
	getEdges2(matrix, edge);
	vector<int> dist(n, INT_MAX);
	vector<int> path(n, -1);
	for(int i = 0; i < n; i++)
	{
		dist[i] = matrix[s][i];
		if(dist[i] == INT_MAX || i == s)
			path[i] = -1;
		else
			path[i] = s;
	}
	dist[s] = 0;
	path[s] = -1;
	for(int i = 0; i < n-1; i++)
	{
		for(int j = 0; j < edge.size(); j++)
		{
			int u = edge[j].head;
			int v = edge[j].tail;
			if(dist[u] != INT_MAX && dist[v] > dist[u] + edge[j].weight)
			{
				dist[v] = dist[u] + edge[j].weight;
				path[v] = u;
			}
		}
	}
	for(int j = 0; j < edge.size(); j++)
	{
		int u = edge[j].head;
		int v = edge[j].tail;
		if(dist[u] != INT_MAX && dist[v] > dist[u] + edge[j].weight)
		{
			cout << "存在负环！" <<endl;
			return;
		}
	}
	printPath(path, dist);
}

int main ()
{
	vector<vector<int>> matrix;
	readData2(matrix);
	bellmanFord(matrix, 0);
	return 0;
}

3. SPFA算法SLF优化（可判定负环, 在部分情况下很快，但不具备普遍性）

#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<stack>
#include<vector>
#include<string>
#include<deque>
using namespace std;

void readData2(vector<vector<int>> & matrix)
{
	int n = 5;
	matrix.resize(n, vector<int>(n, INT_MAX));
	for(int i = 0; i < n; i++)
	{
		matrix[i][i] = 0;
	}
	matrix[0][1] = 10;
	matrix[0][3] = 30;
	matrix[0][4] = 100;
	matrix[1][2] = 50;
	matrix[2][4] = 10;
	matrix[3][2] = 20;
	matrix[3][4] = -60;  //[4][3]即有负环
}

void printPath(vector<int>& path, vector<int>& dist)
{ 
	int n = path.size();
	for(int i = n-1; i >= 1; i--)
	{
		vector<int> t;
		int k = i;
		while(k != -1)
		{
			t.insert(t.begin(),k);
			k = path[k];
		}
		cout << t[0];
		for(int j = 1; j < t.size(); j++)
			cout << " ---> " << t[j];
		cout<<"( dist = "<<dist[i]<<" )"<<endl;
	}
}

void spfa(vector<vector<int>> &matrix, int s)
{
	int n = matrix.size();
	vector<int> dist(n, INT_MAX);
	vector<int> path(n, -1);
	vector<bool> visited(n, false);
	vector<int> cnt(n, 0);
	deque<int> q;
	dist[s] = 0;
	path[s] = -1;
	visited[s] = true;
	cnt[s]++;
	q.push_back(s);
	while(!q.empty())
	{
		int u = q.front();
		q.pop_front();
		visited[u] = false;
		for(int v = 0; v < n; v++)
		{
			if(matrix[u][v] != INT_MAX)
			{
				if(dist[u] != INT_MAX && dist[v] > dist[u] + matrix[u][v])
				{
					dist[v] = dist[u] + matrix[u][v];
					path[v] = u;
					if(!visited[v])
					{
						if(q.empty())
							q.push_back(v);
						else
						{
							if(dist[v] < dist[q.front()])  //SLF优化
								q.push_front(v);
							else
								q.push_back(v);
						}
						visited[v] = true;
						cnt[v]++;
						if(cnt[v] >= n)
						{
							cout << "存在负环!" <<endl;
							return;
						}
					}
				}
			}
		}
	}
	printPath(path, dist);
}

int main ()
{
	vector<vector<int>> matrix;
	readData2(matrix);
	spfa(matrix, 0);
	return 0;
}

4. Floyd每对顶点间最短路径算法（可以有负权边，但不能有负环）

#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<stack>
#include<vector>
#include<string>
#include<deque>
using namespace std;

void readData2(vector<vector<int>> & matrix)
{
	int n = 5;
	matrix.resize(n, vector<int>(n, INT_MAX));
	for(int i = 0; i < n; i++)
	{
		matrix[i][i] = 0;
	}
	matrix[0][1] = 10;
	matrix[0][3] = 30;
	matrix[0][4] = 100;
	matrix[1][2] = 50;
	matrix[2][4] = 10;
	matrix[3][2] = 20;
	matrix[3][4] = -60;
}

void printPath2(int u, int v, vector<vector<int>>& path)
{ 
    if(path[u][v] == -1)
        return;
    printPath2(u, path[u][v], path);
	cout << path[u][v] << " ---> ";
    printPath2(path[u][v], v, path);
}

void floyd(vector<vector<int>> &matrix)
{
	int n = matrix.size();
	vector<vector<int>> dp(n, vector<int>(n, 0));
	vector<vector<int>> path(n, vector<int>(n, -1));
	for(int i = 0; i < n; i++)
	{
		for(int j = 0; j < n; j++)
		{
			dp[i][j] = matrix[i][j];
		}
	}
	for(int k = 0; k < n; k++)
	{
		for(int i = 0; i < n; i++)
		{
			for(int j = 0; j < n; j++)
			{
				if((dp[i][k] != INT_MAX) && (dp[k][j] != INT_MAX) && (dp[i][j] > dp[i][k]+dp[k][j]))
				{
					dp[i][j] = dp[i][k]+dp[k][j];
					path[i][j] = k;
				}
			}
		}
	}
	for(int i = 0; i < n; i++)
	{
		for(int j = i+1; j < n; j++)
		{
			if(dp[i][j] < INT_MAX)
			{
				cout << i << " --> ";
				printPath2(i,j,path);
				cout<<j<<"( dist = " << dp[i][j] << " )"<<endl;
			}
		}
	}	
}

int main ()
{
	vector<vector<int>> matrix;
	readData2(matrix);
	floyd(matrix);
	return 0;
}

三、拓扑排序算法

#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<stack>
#include<vector>
#include<string>
#include<deque>
using namespace std;

struct Edge
{
	int head;
	int tail;
	int weight;
};

void readData3(vector<vector<int>> & matrix)
{
	int n = 7;
	matrix.resize(n, vector<int>(n, INT_MAX));
	for(int i = 0; i < n; i++)
	{
		matrix[i][i] = 0;
	}
	matrix[0][2] = 1;
	matrix[2][3] = 1;
	matrix[1][3] = 1;
	matrix[1][6] = 1;
	matrix[1][4] = 1;  //改成[4][1]即有环
	matrix[3][4] = 1;
	matrix[3][5] = 1;
	matrix[6][5] = 1;
}

void getEdges2(vector<vector<int>> &matrix, vector<Edge>& edges)
{
	int n = matrix.size();
	for(int i = 0; i < n; i++)
	{
		for(int j = 0; j < n; j++)
		{
			if(matrix[i][j] != INT_MAX && matrix[i][j] != 0)
			{
				Edge e;
				e.head = i;
				e.tail = j;
				e.weight = matrix[i][j];
				edges.push_back(e);
			}
		}
	}
}

void topoSort(vector<vector<int>>& matrix)
{
	int n = matrix.size();
	vector<int> arr;
	vector<Edge> edge;
	getEdges2(matrix, edge);
	vector<int> indegree(n, 0);
	queue<int> q;
	for(int i = 0; i < edge.size(); i++)
		indegree[edge[i].tail]++;
	for(int i = 0; i < n; i++)
	{
		if(indegree[i] == 0)
			q.push(i);
	}
	while(!q.empty())
	{
		int u = q.front();
		q.pop();
		arr.push_back(u);
		for(int i = 0; i < edge.size(); i++)
		{
			if(edge[i].head == u)
			{
				int v = edge[i].tail;
				indegree[v]--;
				if(indegree[v] == 0)
					q.push(v);
			}
		}
	}
	if(arr.size() == n)
	{
		cout << arr[0];
		for(int i = 1; i < arr.size(); i++)
			cout << " --> " << arr[i];
		cout<<endl;
	}
	else
		cout << "图中存在环路!" <<endl;

}

int main ()
{
	vector<vector<int>> matrix;
	readData3(matrix);
	topoSort(matrix);
	return 0;
}
鳜鱼的男盆友
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解图的应用（最小生成树、拓扑排序、关键路径、最短路径）
12-26
1.最小生成树：无向连通图的所有生成树中有一棵边的权值总和最小的生成树 1.1 问题背景： 假设要在n个城市之间建立通信联络网，则连通n个城市只需要n—1条线路。这时，自然会考虑这样一个问题，如何在最节省经费的...
最小生成树、最短路径、拓扑排序、关键路径
gets_s的博客
06-24 734
普利姆算法和克鲁斯卡尔算法是两个利用MST性质构造最小生成树的算法。 一、普利姆算法（“加点法”） 二、克鲁斯卡尔算法
算法复习——图算法篇之最小生成树之Kruskal算法
NickHan_cs的博客
01-26 430
算法复习——图算法篇之最小生成树之Kruskal算法 以下内容主要参考中国大学MOOC《算法设计与分析》，墙裂推荐希望入门算法的童鞋学习！ 1. 问题回顾 ​ 问题背景、问题定义和通用框架可见算法复习——图算法篇之最小生成树之Prim算法。 2. Kruskal算法 Prim算法和Kruskal算法最大的不同是，Prim算法始终维持边集A AA一棵树，规避了无环图的判断，且整个过程中只有两个割集，每次都要去寻找这两个割集的轻边，并加入图中；而Kruskal算法中，每一步中可能有多个割集，按顺序加入边
Kruskal算法的正确性证明
qq_40759483的博客
12-08 4110
（1）算法说明： 输入图G=(V,E,W), V={1,2,…,n} ; 输出图G的最小生成树T 设计思想：按照长度从小到大对边排序；依次考察当前最短边e，如果e与T的边不构成回路，则把e加入树T，否则跳过e直到选择了n-1条边为止。 （2）证明思路： 命题：对于任意n，算法对n阶图找到一棵最小生成树 归纳基础：证明n=2时算法正确 归纳步骤： 证明：假设算法对于n阶图是正确的，其中n>1，则对于任何n+1阶图算法也得到一棵最小生成树 （3）证明 ①、归纳基础证明： n=2时，图G只有一条边，显然当前
图——最小生成树的两种算法
weixin_62917800的博客
07-15 2478
还不理解普里姆算法和克鲁斯卡尔算法？赶快来看这篇文章！
数据结构课程设计 最小生成树，拓扑排序以及最短路径
MAX_xihuanni的博客
03-10 1327
通信网络的架设问题 【问题描述】 若要在n（≥10）个城市之间建设通信网络，只需要架设n-1条线路即可，如何以最低的经济代价建设这个通信网，是一个网的最小生成树问题。 【基本要求】 （1）利用二种方法（Prim算法和克鲁斯卡尔（Kruskual）生成网中的最小生成树。 （2）求出任意两个城市之间通信的最短距离。 （3）将n个城市设计为一个DAG图，求出一组拓扑排序序列和关键路径。 #include<stdio.h> #include<malloc.h> #define
详解图的应用（最小生成树拓扑排序关键路径最短路径）共26页
10-31
本文将深入探讨图的应用，重点集中在最小生成树、拓扑排序、关键路径和最短路径这四个核心概念。这些概念在实际问题解决中具有极高的实用价值，对于理解和解决复杂系统的问题至关重要。 首先，我们来看最小生成树。...
图的判断 图的拓扑排序 单源最短路径 求最大生成树
09-07
图的判断、图的拓扑排序、单源最短路径以及求最大生成树是图论中的核心算法，它们在很多实际问题中有着广泛的应用，如网络设计、任务调度、交通规划等。 首先，我们来探讨“图的判断”。在编程中，图通常用邻接矩阵...
图算法演示系统----最小生成树，最短路径，拓扑排序，关键路径
09-20
在给定的“图算法演示系统”中，我们可以看到几个核心概念：最小生成树、最短路径、拓扑排序以及关键路径。这些都是图论中的基础算法，广泛应用于网络设计、任务调度、资源分配等领域。 1. 最小生成树（Minimum ...
图的应用：最小生成树、最短路径、拓扑排序、关键路径
weixin_46432495的博客
10-12 489
最小生成树： 在图的所有生成树中，各边代价之和最小的那棵生成树称为最小代价生成树，简称最小生成树； 利用MST性质构造的算法：Prim、Kruskal Prim： 初始u为v1，找v1的权值最小的边，<v1,v3> 找与v1、v3连接的权值最小的边，<v3,v6> 找与v1,v3，v6连接的权值最小的边，<v6,v4> 找v1,v3，v6，v4连接的权值最小的边，<v3,v2> 找v1,v3，v6，v4，v2连接的权值最小的边，&lt..
最短路径树(图)
qq_45666842的博客
05-05 3023
在无向图中寻找最短路径使用广度优先的搜索方法，当边是有向时依然可以用广度优先搜索方法，因为边没有权重，最短路径就是经过最少的顶点到达目标顶点。但是假如边是有权重的时候该方法就不再适用了。(下面的例子跟上面的一句话完全没关系)。 刚下火车站到一个陌生的地方问图书馆怎么走，人家说有两条路 1、沿着这条路走到市政府门口然后右转就到了，这条路稍微远点 2、出火车站往东南方向走进入一个小区，沿着小区里的那条大路走到小喷泉然后右拐，走到8号楼门前在其右前方有个小门，出了小门有个菜...
最小生成树(Prim,Kruskal)--最短路径(Dijkstra,Floyd)算法详解
qq_45882032的博客
09-27 4694
以某一个顶点开始构建生成树，每次将代价最小的新顶点纳入生成树，直到所有顶点都纳入位置。设有如下图： 从P点开始构建生成树，选择其他顶点也可 首先与P相连最小的代价（边）是学校，代价为1，将其并入： 此时与生成树相连的边有5，6，5，4，6，4，最小的代价时连渔村或者矿场，我们这里选择连矿场，选渔村的话生成的最小生成树代价不变，所以同一个图可以有多个最小生成树此时最小树生成树如图： 再选择代价最小的顶点并入生成树，依此类推，最小生成树： 每次选择一条权值最小的边，使这条边的两头联通(原本已经联通的就不选
【算法精讲】最小树形图 (两份讲解 配套例题)
Suprit's blog
06-14 1669
其一 概述 最小树形图, 简而言之就是求有向带权图的最小生成树. 官方定义是这样的: 最小树形图，就是给有向带权图中指定一个特殊的点root，求一棵以root为根的有向生成树T，并且T中所有边的总权值最小。 通解最小树形图的一种算法是是1965年朱永津和刘振宏提出的复杂度为O(VE)的算法：朱、刘算法。 今天我们就来浅谈一下最小树形图的问题。 最小树形图, 简而言之就是求有向带权图的最小生成树....
程序员的算法课（20）-常用的图算法：最小生成树（MST）
十步杀一人-千里不留行
08-27 1522
一、图的生成树和最小生成树 生成树(SpanningTree)：如果一个图的子图是一个包含图所有节点的树，那这个子图就称为生成树。图的生成树不惟一。从不同的顶点出发进行遍历，可以得到不同的生成树。专业的说法：在一个无向连通图中，如果存在一个连通子图包含原图中所有的结点和部分边，且这个子图不存在回路，那么我们称这个子图为原图的一棵生成树。 最小生成树：在带权图中，所有的生成树中边权和最小的那棵（...
图基本算法 最小生成树 Prim算法（邻接表/邻接矩阵+优先队列STL）
热门推荐
Tham 在思索中前行！
05-27 1万+
这篇文章是对《算法导论》上Prim算法求无向连通图最小生成树的一个总结，其中有关于我的一点点小看法。 　　最小生成树的具体问题可以用下面的语言阐述： 　　　　输入：一个无向带权图G=(V,E)，对于每一条边(u, v)属于E，都有一个权值w。 　　　　输出：这个图的最小生成树，即一棵连接所有顶点的树，且这棵树中的边的权值的和最小。 　　举例如下，求下图的最小生成树：
图的最小生成树算法
ChanCherry的博客
05-17 2767
生成树：一个连通图的生成树是指一个极小连通子图，含有图中的全部n个顶点，但只有足以构成一棵树的n-1条边。 构造网的一棵最小生成树，即：在e条带权的边中选取n-1条边，不构成回路，使“权值之和”最小。 最小生成树要解决的问题： 尽可能选取权值小的边，但不能构成回路； 选取n-1条恰当的边以连接网的n个顶点。 Prim算法（普里姆算法） Prim算法思想 取图中任意一个顶点v作为生成树的根，之后往生成树上添加新的顶点w，注意添加的这个顶点要使该边的权值在所有连通顶点v和w之间的边中取值最小。之后继续往生成
图的最小生成树-普里姆算法
xiezhi123456的博客
02-28 6038
一、基本概念 生成树：一个连通图的生成树是一个极小的连通子图，它含有图中全部的顶点，但只有足以构成一棵树的n-1条边。 最小生成树：把构造连通网的最小代价生成树称为最小生成树。（一棵生成树的代价就是树上各边的代价之和）。 二、经典算法 1、普里姆算法（主要针对顶点展开的，对于稠密图，即边数非常多的情况会更好一些） 主要思路如下图所示： 如上图所示，假设首先从零点出发，并将零点涂为黑...
【数据结构与算法】最小生成树 | 最短路径
最新发布
joy.728的博客
02-02 2470
本篇博客主要讲解了最小生成树的 Kruskal 算法和 Prim 算法以及最短路径的 Dijkstra 算法、BellmanFord 算法和 FloydWarshall 算法等。
pcl最小图割（pcl::MinCutSegmentation)算法
bBoy_Stte的博客
12-17 2199
背景知识： 最小割算法是图论中的一个概念，其作用是以某种方式，将两个点分开，当然这两个点中间可能是通过无数的点再相连的。 图一 此类方法把图像分割问题与图的最小割（min cut）问题相关联。首先用一个无向图G=<V，E>表示要分割的图像，V和E分别是顶点（vertex）和边（edge）的集合。 此处的Graph和普通的Graph稍有不同。普通的图分为有向图和无向图；由顶点和边...
图论算法详解：最小生成树与最短路径
"本文主要介绍了图论中的四种经典算法，包括最小生成树算法、最短路径算法、拓扑排序算法和关键路径算法。重点讲解了最小生成树算法，特别是生成树的概念及其在连通无向图和有向图中的应用。生成树不唯一，根据不同...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值