最短路和最小生成树

最新推荐文章于 2024-07-19 13:59:11 发布
最新推荐文章于 2024-07-19 13:59:11 发布
阅读量77 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daogujufeng/article/details/131652154
版权

最短路和最小生成树（注意事项以及代码分析）

1 Dijkstra(求最短路)

1.1 Dijkstra具体过程

1：进行n次迭代每次迭代中，找出未确认最短路的点。
2: 通过这个点对其他点进行松弛操作。并将该带标记为
   最短路。

1.2 Dijkstra代码(朴素版本 邻接矩阵)

Dijkstra题目链接

#include<iostream>
#include<algorithm>
#include<unordered_map>
#include<queue>
#include<cstring>

using namespace std;

typedef pair<int, int> PII;
typedef long long ll;
int const INF = 0x3f3f3f3f;
//-------------------------------------------------------
int const N = 510;
int n, m;
int map[N][N],dist[N];
bool book[N];
//-------------------------------------------------------
void init()
{
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			if (i == j) map[i][j] = 0;
			else map[i][j] = INF;
		}
	}
}

int dijkstra()
{
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;
	for (int i = 1; i <= n; i++)
	{
		int t = -1;
		for (int j = 1; j <= n; j++)
			if ((t == -1 || dist[t] > dist[j]) && !book[j]) t = j;

		for (int j = 1; j <= n; j++)
			dist[j] = min(dist[j], dist[t] + map[t][j]);

		book[t] = true;
	}
	if (dist[n] != INF) return dist[n];
	return -1;
}

//-------------------------------------------------------
int main()
{
	cin >> n >> m;
	init();
	for (int i = 1; i <= m; i++)
	{
		int a, b, len; cin >> a >> b >> len;
		map[a][b] = min(map[a][b], len);
	}
	int ans = dijkstra();
	cout << ans << endl;
}
//-------------------------------------------------------
/*

*/

1.3 Dijkstra代码(堆优化版本 邻接表)

Dijkstra题目链接

#include<iostream>
#include<algorithm>
#include<unordered_map>
#include<queue>
#include<cstring>

using namespace std;

typedef pair<int, int> PII;
typedef long long ll;
int const INF = 0x3f3f3f3f;
//-------------------------------------------------------
int const N = 3e5 + 10;
int n, m;
int h[N], ne[N], e[N], w[N], dist[N], idx;
bool book[N];
//-------------------------------------------------------

void init()
{
	memset(h, -1, sizeof h);
	idx = 0;
}

void add(int a, int b, int len)
{
	e[idx] = b;
	w[idx] = len;
	ne[idx] = h[a];
	h[a] = idx++;
}

int dijkstra()
{
	memset(dist, 0x3f, sizeof dist);					
	dist[1] = 0;									//初始化dist数组
	priority_queue<PII,vector<PII>,greater<PII>> que;//定义大根堆维护dist数组
	que.push({ 0,1 });								//fistr 表示距离 second 表示点
	while (!que.empty())
	{
		PII t = que.top(); que.pop();
		int ver = t.second;
		if (book[ver] == true) continue;
		book[ver] = true;
		for (int i = h[ver]; i != -1; i = ne[i])
		{
			int j = e[i];
			if (dist[j] > dist[ver] + w[i])
			{
				dist[j] = dist[ver] + w[i];
				que.push({ dist[j],j });
			}
		}
	}
	if (dist[n] == INF) return -1;
	return dist[n];
}
//-------------------------------------------------------
int main()
{
	init();											//初始化 h[]
	cin >> n >> m; 
	for (int i = 1; i <= m; i++)
	{
		int a, b, len; cin >> a >> b >> len;
		add(a, b, len);
	}
	int ans = dijkstra();
	cout << ans << endl;
}
//-------------------------------------------------------

/*

*/

1.4 Dijkstra总结

图的存储方式
1.邻接矩阵（稠密图）：

    在初始化的过程中如果存在重边将最短的存入图中
    
2.邻接表（稀疏图）：

    h[],ne[],e,w,idx;
    
    void init()
    {
	    idx = 0;
	    memset(h, -1, sizeof h);
    }

    void add(int a, int b,int len)
    {
    	e[idx] = b;
    	w[idx] = len;
    	ne[idx] = h[a];
    	h[a] = idx++;
    }
Dijkstra 细节问题
  1. Dijkstra 适用于权值不为负的。
  2. 在Dijkstra的堆优化中，first必须是距离只有这样，堆才会按照距离排序

2 spfa bellman-ford（求最短路）

2.1 bellman-ford

  1. 将边用结构体存储，通过权值进行排序。
  2. 通过n-1次迭代更新dist[]数组求出最短路（其中n-1是边数限制，如果n次之后还存在边更新说明有负环）

2.2 bellman-ford 代码

bellman-ford

#include<iostream>
#include<algorithm>
#include<unordered_map>
#include<queue>
#include<cstring>

using namespace std;

typedef pair<int, int> PII;
typedef long long ll;
int const INF = 0x3f3f3f3f;
//-------------------------------------------------------
int const N = 1e4 + 10;
int n, m, k;
int dist[N], backup[N];
struct edge
{
	int a, b, len;
}e[N];
//-------------------------------------------------------
int main()
{
	cin >> n >> m >> k;
	for (int i = 1; i <= m; i++)
		cin >> e[i].a >> e[i].b >> e[i].len;
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;
	for (int i = 1; i <= k; i++)
	{
		memcpy(backup, dist, sizeof dist);
		for (int j = 1; j <= m; j++)
		{
			int a = e[j].a;
			int b = e[j].b;
			int len = e[j].len;
			dist[b] = min(dist[b], backup[a] + len);
		}
	}
	if (dist[n] > INF / 2) cout << "impossible" << endl;
	else cout << dist[n] << endl;
}
//-------------------------------------------------------

/*

*/

2.3 bellman-ford注意事项

  1. 通过backup数组防止发生串联
  2. 由于途中存在权值为负的边，并且在更行时所有边都会便利到，所以无法到达的距离可能小于INF
  3. 当k>=n dist仍然变化说明存在负环

2.4 spfa

  1. 相当于bellman-ford的优化，由于dist[b]要改变必须存在dist[a]变小。
  2. 开一个对联存储改变的dist[a]
  3. 一直循环直到队列位0

2.5 spfa 代码

spfa

#include<iostream>
#include<algorithm>
#include<unordered_map>
#include<queue>
#include<cstring>

using namespace std;

typedef pair<int, int> PII;
typedef long long ll;
int const INF = 0x3f3f3f3f;
//-------------------------------------------------------
int const N = 1e5 + 10;
int n, m;
int h[N], ne[N], w[N], e[N], dist[N], idx;
bool book[N];

void init()
{
	memset(dist, 0x3f, sizeof dist);
	memset(h, -1, sizeof h);
	idx = 0;
}

void add(int a,int b,int len)
{
	e[idx] = b;
	ne[idx] = h[a];
	w[idx] = len;
	h[a] = idx++;
}

int spfa()
{
	dist[1] = 0;
	queue<int> que;
	que.push(1);
	while (!que.empty())
	{
		int t = que.front(); que.pop();
		book[t] = false;
		for (int i = h[t]; i != -1; i = ne[i])
		{
			int j = e[i];
			if (dist[j] > dist[t] + w[i])
			{
				dist[j] = dist[t] + w[i];
				if (!book[j])
				{
					book[j] = true;
					que.push(j);
				}
			}
		}
	}
	return dist[n];
}

//-------------------------------------------------------
int main()
{
	init();
	cin >> n >> m;
	for (int i = 1; i <= m; i++)
	{
		int a, b, len; cin >> a >> b >> len;
		add(a, b, len);
	}
	int ans = spfa();
	if (ans == INF) cout << "impossible" << endl;
	else cout << ans << endl;

}
//-------------------------------------------------------

/*

*/

2.6 spfa判断负环

  1. 通过维护一个cnt[],判断起点到当前点走过的边数，如果边数大于等于n说明存在负环。
  2. queue<> 初始载入所有点

spfa判断负环

#include<iostream>
#include<algorithm>
#include<unordered_map>
#include<queue>
#include<cstring>

using namespace std;

typedef pair<int, int> PII;
typedef long long ll;
int const INF = 0x3f3f3f3f;
//-------------------------------------------------------
int const N = 1e5 + 10;
int n, m;
int h[N], ne[N], w[N], e[N], dist[N], cnt[N], idx;
bool book[N];

void init()
{
	memset(dist, 0x3f, sizeof dist);
	memset(h, -1, sizeof h);
	idx = 0;
}

void add(int a,int b,int len)
{
	e[idx] = b;
	ne[idx] = h[a];
	w[idx] = len;
	h[a] = idx++;
}

bool spfa()
{
	dist[1] = 0;
	queue<int> que;
	for (int i = 1; i <= n; i++) que.push(i);
	while (!que.empty())
	{
		int t = que.front(); que.pop();
		book[t] = false;
		for (int i = h[t]; i != -1; i = ne[i])
		{
			int j = e[i];
			if (dist[j] > dist[t] + w[i])
			{
				cnt[j]++;
				if (cnt[j] >= n) return true;
				dist[j] = dist[t] + w[i];
				if (book[j]==false)
				{
					book[j] = true;
					que.push(j);
				}
			}
		}
	}
	return false;
}

//-------------------------------------------------------
int main()
{
	init();
	cin >> n >> m;
	for (int i = 1; i <= m; i++)
	{
		int a, b, len; cin >> a >> b >> len;
		add(a, b, len);
	}
	if (spfa()) cout << "Yes" << endl;
	else cout << "No" << endl;
}
//-------------------------------------------------------

/*

*/

2.7 spfa注意事项

  1. spfa是由bellman-ford优化而来的时间复杂度远小于O（nm）。
  2. spfa不需要backup是由于bellman—ford的上一题是有边数限制的最短路防止串联，而spfa单纯就是求最短路所以不需要考虑串联。
  3. spfa无穷远不会更新位小于INF由于dist[b]的前驱一定是更新过的，才会进行与后继最短路求解，所以INF与INF的比较是不会进行的，因此负权无法更新无穷大。

3 Floyd

3.1 Floyd求最短路

  1. 动态规划，三重循环，松弛操作

3.2 Floyd代码

#include<iostream>
#include<algorithm>
#include<unordered_map>
#include<queue>
#include<cstring>

using namespace std;

typedef pair<int, int> PII;
typedef long long ll;
int const INF = 0x3f3f3f3f;
//-------------------------------------------------------
int const N = 210;
int map[N][N];
int n, m, t;

void init()
{
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= n; j++)
			if (i == j) map[i][j] = 0;
			else map[i][j] = INF;
}

//-------------------------------------------------------
int main()
{
	cin >> n >> m >> t;
	init();
	for (int i = 1; i <= m; i++)
	{
		int a, b, len; cin >> a >> b >> len;
		map[a][b] = min(map[a][b], len);
	}
	
	for (int k = 1; k <= n; k++)
		for (int i = 1; i <= n; i++)
			for (int j = 1; j <= n; j++)
				map[i][j] = min(map[i][j], map[i][k] + map[k][j]);

	while (t--)
	{
		int a, b; cin >> a >> b;
		if (map[a][b] >= INF / 2) cout << "impossible" << endl;
		else cout << map[a][b] << endl;
	}
}
//-------------------------------------------------------

/*

*/

3 prim Kruskal最小生成树

3.1 prim算法

  1. 进行n次迭代，每次找到距离集合最近且未标记过的点，res+=dist[t]。
  2. 用t更新其他点

3.2 prim 代码

prim

#include<iostream>
#include<algorithm>
#include<unordered_map>
#include<queue>
#include<cstring>

using namespace std;

typedef pair<int, int> PII;
typedef long long ll;
int const INF = 0x3f3f3f3f;
//-------------------------------------------------------
int const N = 510;
int map[N][N],dist[N];
int n, m;
bool book[N];

void init()
{
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			if (i == j) map[i][j] = 0;
			else map[i][j] = INF;
		}
	}
}

int prim()
{
	int res = 0;
	memset(dist, 0x3f, sizeof dist);
	for (int i = 1; i <= n; i++)
	{
		int t = -1;
		for (int j = 1; j <= n; j++)
			if ((t == -1 || dist[t] > dist[j]) && !book[j]) t = j;

		if (i != 1 && dist[t] == INF) return INF;
		if (i != 1) res += dist[t];

		for (int j = 1; j <= n; j++)
			dist[j] = min(dist[j], map[t][j]);

		book[t] = true;
	}
	return res;
}

//-------------------------------------------------------
int main()
{
	cin >> n >> m;
	init();
	for (int i = 1; i <= m; i++)
	{
		int a, b, len; cin >> a >> b >> len;
		map[a][b] = map[b][a] = min(map[a][b], len);
	}
	int ans = prim();
	if (ans == INF) cout << "impossible" << endl;
	else cout << ans << endl;
}
//-------------------------------------------------------

/*

*/

3.3 Kruskal

  1. 将所有边排序
  2. 从小到达枚举如果不连通就联通一下

3.4 Kruskal 代码

Kruskal

#include<iostream>
#include<algorithm>
#include<unordered_map>
#include<queue>
#include<cstring>

using namespace std;

typedef pair<int, int> PII;
typedef long long ll;
int const INF = 0x3f3f3f3f;
//-------------------------------------------------------
int const N = 1e5 + 10, M = 2e5 + 10;
int p[N];
struct edge
{
	int a, b, len;
}e[M];

bool cmp(edge a, edge b)
{
	return a.len < b.len;
}

int find(int x)
{
	if (p[x] != x) p[x] = find(p[x]);
	return p[x];
}
//-------------------------------------------------------
int main()
{
	int n, m; cin >> n >> m;
	for (int i = 1; i <= m; i++)
	{
		int a, b, len; cin >> a >> b >> len;
		e[i] = { a,b,len };
	}

	sort(e + 1, e + 1 + m, cmp);
	for (int i = 1; i <= n; i++) p[i] = i;

	int ans = 0; int cnt = 0;
	for (int i = 1; i <= m; i++)
	{
		int a = e[i].a;
		int b = e[i].b;
		int len = e[i].len;
		a = find(a);
		b = find(b);
		if (a != b)
		{
			cnt++;
			ans += len;
			p[a] = b;
		}
	}
	if (cnt < n - 1) cout << "impossible" << endl;
	else cout << ans << endl;
}
//-------------------------------------------------------

/*

*/
道古九封
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
最短路树 科普笔记
cryozwq的博客
09-01 572
一个非常冷门的知识点（大概吧） 基础定义 定义：一个 nnn 个点，mmm 条边的无向图，最短路树是图上的一棵生成树，以一个节点 xxx 为根，满足对于任意 i(1≤i≤n,i≠x)i(1\le i\le n,i\neq x)i(1≤i≤n,i​=x)，树上两点最短路的距离等于原图两点最短路距离。 性质：第一个即是其定义，第二个是我这个民科自己想的，不一定对：对于两个节点 u,vu,vu,v 满足同属于最短路树上的一条链，那么二者原图上的最短路就是树上两点到根节点距离之差。（证明：考虑反证，若两点有更短的
图论基础之最短路和最小生成树
m0_55341679的博客
10-09 468
最短路和最小生成树
最短路径树(图)
qq_45666842的博客
05-05 3024
在无向图中寻找最短路径使用广度优先的搜索方法，当边是有向时依然可以用广度优先搜索方法，因为边没有权重，最短路径就是经过最少的顶点到达目标顶点。但是假如边是有权重的时候该方法就不再适用了。(下面的例子跟上面的一句话完全没关系)。 刚下火车站到一个陌生的地方问图书馆怎么走，人家说有两条路 1、沿着这条路走到市政府门口然后右转就到了，这条路稍微远点 2、出火车站往东南方向走进入一个小区，沿着小区里的那条大路走到小喷泉然后右拐，走到8号楼门前在其右前方有个小门，出了小门有个菜...
最短路树（SPT
zlq7777的博客
01-13 312
D. Edge Deletion
最短路树学习笔记及例题
caoyang1123的博客
04-15 2102
定义构建一棵树，使得任意不属于根的节点x，dis(root,x)=原图走到x的最短路。 构建方法：就是在跑dijkstra时同时维护每个点是哪个点哪条边更新的，这个点这条边就是它在最短路树上的父亲/到父亲的边 例题： T1.bzoj3694 最短路 题意：给定了最短路树要求不经过树上到i点最后一条边的到i点最短路。 显然到一个点走法一定是经过一条非树边到达的，那么考虑每一条非树边会产生怎...
最短路与最小生成树
xiaoxiede_wo的博客
07-04 1413
最小生成树能够保证整个拓扑图的所有路径之和最小，但不能保证任意两点之间是最短路径。 最短路径是从一点出发，到达目的地的路径最小。 一句话概括：最小生成树是计算从一节点到另一节点的最小边集；最短路是带权路径，计算权值最小。 也就是说，最小生成树要经过每一个点，而最短路只需要能达到某两点，路径权值最小即可！** 最短路的算法有Floyd、Dijkstra、Bellman,SPFA 单源就是从...
最小生成树和最短路径
qq91752728的博客
06-23 2321
这篇算作是《算法》第四版部分读后感吧 我思考这个问题的开始就是纠结最小生成树prim算法和最短路径dijkstra算法的异同 1.最小生成树prim算法 直接从例子开始吧，我们考虑一副这样的图 1.将D设为起始点(设置某个点为起始点是随机的)，考虑与它相邻节点的权重值，图中黄色节点，也就是D-A,D-B,D-E,D-F 2.选取权重值最小的D-A将其连接,图中蓝色的代表已经加入到...
720-图论二(最短路和最小生成树).pptx
10-22
【最小生成树】最小生成树问题是在加权无向图中寻找一棵包含所有顶点的树，使得树的所有边的权重之和最小。最小生成树可以用来解决网络连接问题，例如在构建通信网络时，如何以最低的成本连接所有城市。有两个经典的...
最短路+最小生成树+矩阵运算(数据结构课程设计)
12-18
总的来说，这个数据结构课程设计涵盖了图论中的重要概念——最短路径和最小生成树，同时涉及了实际应用中的城市规划问题。通过实现Prim和Kruskal算法，学生可以深入理解这两种算法的工作原理，并通过迪杰斯特拉算法...
数据结构基础班最短路径最小生成树
04-09
在本课程“数据结构基础班最短路径最小生成树”中，我们将深入探讨两个关键概念：最小生成树和最短路径。这些知识点在解决实际问题，如网络设计、交通规划等中具有广泛的应用。 首先，我们要理解什么是最小生成树。...
最小生成树与最短路
02-06
关于近年最小生成树和最短路算法在ACM竞赛中的应用
2. 最短路、最小生成树(1).R.r
10-25
2. 最短路、最小生成树(1).R.r
【TJOI2012】桥（最短路径树）
xyyxyyx的博客
09-22 438
文章目录题意思路代码 题意 一张有向图，求去掉任意一条边后使得最短路最长。求最长的最短路长度以及删边的方案数。 思路 题解都说是最短路径树，但是实际上这棵树不用建出来，所以也就是一个思路而已。 首先找到一条最短路，可以知道能删的边肯定在这条路径上。可以想象一下，就算有多条最短路也不用管，只要找出一条就好了。 然后试着删掉一条边，删边之后的最短路必然要经过至少一条不在这条路径上的边。我们枚举新最短路...
『最短路树问题』最短路
Ronaldo7_ZYB的博客
09-02 547
Problem\mathrm{Problem}Problem Solution\mathrm{Solution}Solution 首先这道题有一个显然的性质： 最短路径最多只经过一条非树边。 因为若有两条非树边(x,y)(x,y)(x,y)和(u,v)(u,v)(u,v)，直接从 111 走到 yyy 显然不会使路径边长。 因此，我们对于每一条非树边都考虑其贡献。 情况1：非树边(u,v,w)(u,v,w)(u,v,w)中，uuu 和 vvv 不存在祖先关系。 贡献为：disu+disv+w−
【最短路】最短路径树入门
qq_43398760的博客
06-04 1736
Description n个城市用m条双向公路连接，使得任意两个城市都能直接或间接地连通。其中城市编号为1..n，公路编号为1..m。 任意个两个城市间的货物运输会选择最短路径，把这n*(n-1)条最短路径的和记为S。现在你来寻找关键公路r，公 路r必须满足：当r堵塞之后，S的值会变大（如果r堵塞后使得城市u和v不可达，则S为无穷大）。 Input 第1行包含两个整数n,m， 接下来的m行，...
bzoj3694[FJOI 2014]最短路题解（超详细） 树链剖分
xm的博客
11-27 332
题目（洛谷上没有就懒得找了）：给出一个 n 个点 m 条边的无向图, n 个点的编号从 1∼n , 定义源点为 1。定义最短路树如下:从源点 1 经过边集 T到任意一点 i 有且仅有一条路径, 且这条路径是整个图 1 到 i 的最短路径, 边集 T 构成最短路树。 给出最短路树, 求对于除了源点 1 外的每个点 i , 求最短路, 要求不经过给出的最短路树上的 1 到 i 的路径的最后一条边。 对...
最短路径树：
_Griefs
08-24 519
一、最短路必经边：先求出任意一条最短路，记录这条最短路上所有的边，枚举这些边： 题目描述 Farmer John 热衷于散步，每天早上他都要从 1 号仓库走到 n 号仓库。 Farmer John 家的 n 个仓库被 m 条双向道路连通起来，每条道路有一个长度 w。而Farmer John 又不喜欢走路，所以他走的是从 1 号仓库到 n 号仓库的最短路。 但是 Farmer 的奶牛们总想搞点事情，...
最小生成树和最短路
weixin_43511247的博客
10-16 843
这周是高产的一周，今天来讲讲图论：最小生成树和最短路： ******************这是一条分割线 最小生成树：一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。 最小生成树可以用kruskal（克鲁斯卡尔）算法或prim（普里姆）算法求出。 效果：最小生成树能够保证整个拓扑图的所有路径之和最小，但不能保证任意两点之间是...
【18】输出字符菱形
最新发布
2301_78786609的博客
07-19 377
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

道古九封

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值