图论 - 最短路径算法

最新推荐文章于 2022-08-24 17:14:22 发布
最新推荐文章于 2022-08-24 17:14:22 发布
阅读量567 收藏
点赞数
分类专栏： 中学生信竞 文章标签： 图论 算法 深度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/davidliule/article/details/122717531
版权
1342：【例4-1】最短路径问题
  • 深搜
#include <bits/stdc++.h>
using namespace std;

const int N = 105;
int n, m, s, t;
struct node{
	int x, y;
	double len;
}p[N];
double e[N][N], ans = 1e9;

void dfs(int i, double dis) {
	if (dis >= p[i].len) return;
	p[i].len = dis;
	
	if (i == t) {
		ans = min(ans, p[i].len);
		return ;
	}

	for (int j = 1; j <= n; j ++) {
		if (e[i][j] > 0) {
			dfs(j, dis + e[i][j]);
		}
	}
}

int main() {
	scanf("%d", &n);
	for (int i = 1; i <= n; i ++) {
		scanf("%d%d", &p[i].x, &p[i].y);
		p[i].len = 1E9;
	}
	
	scanf("%d", &m);
	for (int i = 1; i <= m; i ++) {
		int a, b;
		scanf("%d%d", &a, &b);
		double len = pow(p[a].x - p[b].x, 2) + pow(p[a].y - p[b].y, 2);
		e[a][b] = e[b][a] = sqrt(len);
	}
	
	scanf("%d%d", &s, &t);
	dfs(s, 0);
	printf("%.2f\n", ans);
	
	return 0;
}
  • floyd
#include <bits/stdc++.h>
using namespace std;

const int N = 105;
int n, m, s, t;
struct node{
	int x, y;
}p[N];
double e[N][N];

void floyd() {
	for (int k = 1; k <= n; k ++) 
		for (int i = 1; i <= n; i ++) 
			for (int j = 1; j <= n; j ++) 
				e[i][j] = min(e[i][j], e[i][k]+e[k][j]);
}

int main() {
	cin >> n;
	for (int i = 1; i <= n; i ++) cin >> p[i].x >> p[i].y;
	
	memset(e, 0x7f, sizeof(e));
	cin >> m;
	for (int i = 1; i <= m; i ++) {
		int a, b;
		cin >> a >> b;
		double len = pow(p[a].x - p[b].x, 2) + pow(p[a].y - p[b].y, 2);
		e[a][b] = e[b][a] = sqrt(len);
	}
	
	cin >> s >> t;	
	floyd();
	printf("%.2f\n", e[s][t]);
	
	return 0;
}
  • dijkstra
#include <bits/stdc++.h>
using namespace std;

const int N = 105;
int n, m, s, t;
struct node{
	int x, y;
}p[N];
double e[N][N];
bool vst[N];

void dijkstra() {
	vst[s] = true;
	
	for (int i = 2; i <= n; i ++) {
		int t = 0;
		for (int j = 1; j <= n; j ++) {
			if (!vst[j] && e[s][j] < e[s][t]) t = j;
		}
		vst[t] = true;
		
		for (int j = 1; j <= n; j ++) {
			if (!vst[j]) e[s][j] = min(e[s][j], e[s][t]+e[t][j]);
		}
	}	
}

int main() {
	cin >> n;
	for (int i = 1; i <= n; i ++) cin >> p[i].x >> p[i].y;
	
	memset(e, 0x7f, sizeof(e));
	cin >> m;
	for (int i = 1; i <= m; i ++) {
		int a, b;
		cin >> a >> b;
		double len = pow(p[a].x - p[b].x, 2) + pow(p[a].y - p[b].y, 2);
		e[a][b] = e[b][a] = sqrt(len);
	}
	
	cin >> s >> t;	
	dijkstra();
	printf("%.2f\n", e[s][t]);
	
	return 0;
}
  • bellman_ford
#include <bits/stdc++.h>
using namespace std;

const int N = 105;
int n, m, s, t;
double dis[N];

struct node {
	int x, y;
}p[N];

struct edge {
	int u, v; 
	double w;
}e[11000];

void bellman_ford() {
	memset(dis, 0x7f, sizeof(dis));
	dis[s] = 0;
	
	for (int i = 1; i < n; i ++) {
		for (int j = 1; j <= 2 * m; j ++) {
			int u = e[j].u, v = e[j].v;
			double w = e[j].w;
			dis[v] = min(dis[v], dis[u] + w);
		}
	}	
}

int main() {
	cin >> n;
	for (int i = 1; i <= n; i ++) cin >> p[i].x >> p[i].y;
	cin >> m;
	for (int i = 1; i <= m; i ++) {
		int u, v;
		cin >> u >> v;
		double w = pow(p[u].x - p[v].x, 2) + pow(p[u].y - p[v].y, 2);
		w = sqrt(w);
		e[2 * i - 1] = {u, v, w};
		e[2 * i] = {v, u, w};
	}
	
	cin >> s >> t;
	bellman_ford();
	printf("%.2f", dis[t]);
	
	return 0;
}
1344：【例4-4】最小花费
#include <bits/stdc++.h> 
using namespace std;

const int N = 2010;
int n, m, a, b;
double e[N][N];
bool vst[N];

void dijkstra() {
	vst[a] = true;
	for (int i = 1; i < n; i ++) {
		int t = 0;
		for (int j = 1; j <= n; j ++) {
			if (!vst[j] && e[a][j] > e[a][t]) t = j;
		}
		vst[t] = true;
		
		for (int j = 1; j <= n; j ++) {
			if (!vst[j]) e[a][j] = max(e[a][j], e[a][t] * e[t][j]);
		}
	}
}

int main() {
	cin >> n >> m;
	while (m --) {
		int x, y, z;
		cin >> x >> y >> z;
		e[x][y] = e[y][x] = (100 - z) / 100.0;
	}

	cin >> a >> b;
	dijkstra();
	printf("%.8f", 100 / e[a][b]);
	
	return 0;
}
1345：【例4-6】香甜的黄油
#include <bits/stdc++.h> 
using namespace std;

const int N = 1000;
int e[N][N], a[N];
int n, p, c;

void floyd() {
	for (int k = 1; k <= p; k ++) 
		for (int i = 1; i <= p; i ++)  
			for (int j = 1; j <= p; j ++) 
				e[i][j] = min(e[i][j], e[i][k] + e[k][j]);
}

int main() {
	memset(e, 0x3f, sizeof(e));
	
	cin >> n >> p >> c;
	for (int i = 1; i <= n; i ++) cin >> a[i];

	for (int i = 1; i <= c; i ++) {
		int u, v, w;
		cin >> u >> v >> w;
		e[u][v] = e[v][u] = w;
	}

	floyd();
	
	//枚举p个牧场，打擂台找到某一个牧场，
	//使得所有奶牛到这个牧场的路程之和最小 
	int minn = 1e9;
	for (int i = 1; i <= p; i++) {
		int sum = 0;
		for (int j = 1; j <= n; j ++) {
			if (a[j] != i) sum += e[i][a[j]];
		}
		minn = min(minn, sum);
	}
	cout << minn;
	
	return 0;
}
1376：信使(msner)
  • floyd
#include <bits/stdc++.h> 
using namespace std;

const int N = 105;
int n, m, e[N][N];

void floyd() {
	for (int k = 1; k <= n; k ++) 
		for (int i = 1; i <= n; i ++)  
			for (int j = 1; j <= n; j ++) 
				e[i][j] = min(e[i][j], e[i][k] + e[k][j]);
}

int main() {
	memset(e, 0x3f, sizeof(e));
	
	cin >> n >> m;
	while (m --) {
		int u, v, w;
		cin >> u >> v >> w;
		e[u][v] = e[v][u] = w;
	}

	floyd();
	
	int ans = 0;
	for (int i = 2; i <= n; i++) {
		if (e[1][i] == 0x3f3f3f3f) {
			cout << -1 << endl;
			return 0;
		}
		ans = max(ans, e[1][i]);
	}
	cout << ans;
	
	return 0;
}
  • dijkstra
#include <bits/stdc++.h> 
using namespace std;

const int N = 105;
int n, m, e[N][N];
bool vst[N];

void dijkstra() {
	vst[1] = true;
	
	for (int i = 1; i < n; i ++) {
		int t = 0;
		for (int j = 1; j <= n; j ++) {
			if (!vst[j] && e[1][j] < e[1][t]) t = j;
		}
		vst[t] = true;
		
		for (int j = 1; j <= n; j ++) {
			if (!vst[j]) e[1][j] = min(e[1][j], e[1][t] + e[t][j]);
		}
	}
}

int main() {
	memset(e, 0x3f, sizeof(e));
	
	cin >> n >> m;
	while (m --) {
		int u, v, w;
		cin >> u >> v >> w;
		e[u][v] = e[v][u] = w;
	}

	dijkstra();
	
	int ans = 0;
	for (int i = 2; i <= n; i++) {
		if (e[1][i] == 0x3f3f3f3f) {
			cout << -1 << endl;
			return 0;
		}
		ans = max(ans, e[1][i]);
	}
	cout << ans;
	
	return 0;
}
1377：最优乘车(travel)
  • 字符输入
#include <bits/stdc++.h> 
using namespace std;

const int N = 510;
int n, m, e[N][N], a[N];

void floyd() {
	for (int k = 1; k <= n; k ++) 
		for (int i = 1; i <= n; i ++)  
			for (int j = 1; j <= n; j ++) 
				e[i][j] = min(e[i][j], e[i][k] + e[k][j]);
}

int main() {
 	memset(e, 0x3f, sizeof(e));
 	
 	scanf("%d%d\n", &m, &n); 	
 	while (m --) {
 		int num = 0, cnt = 0;
 		char ch;
 		while (scanf("%c", &ch)) {
			if (ch >= '0' && ch <= '9') {
				num = num * 10 + ch - '0';
			}
			else {
				a[++ cnt] = num;
				num = 0;
 				if (ch == '\n') break;
			}
		}
		
 		for (int i = 1; i <= cnt; i ++) {
 			for (int j = i + 1; j <= cnt; j ++) {
 				e[a[i]][a[j]] = 1;
			}
 		}
	}
	
	floyd();
	
	if (e[1][n] == 0x3f3f3f3f) cout << "NO";
	else cout << e[1][n] - 1;
	
	return 0;
}
  • 字符串输入
#include <bits/stdc++.h> 
using namespace std;

const int N = 510;
int n, m, e[N][N], a[N];

void floyd() {
	for (int k = 1; k <= n; k ++) 
		for (int i = 1; i <= n; i ++)  
			for (int j = 1; j <= n; j ++) 
				e[i][j] = min(e[i][j], e[i][k] + e[k][j]);
}

int main() {
 	memset(e, 0x3f, sizeof(e));
 	
 	scanf("%d%d\n", &m, &n); 	
 	while (m --) {
 		string s;
 		getline(cin, s);
		s = s + ' ';
		
		int num = 0, cnt = 0;
 		for (int i = 0; i < s.size(); i ++) {
			if (s[i] >= '0' && s[i] <= '9') {
				num = num * 10 + s[i] - '0';
			}
			else {
				a[++ cnt] = num;
				num = 0;
			}
		}
		
 		for (int i = 1; i <= cnt; i ++) {
 			for (int j = i + 1; j <= cnt; j ++) {
 				e[a[i]][a[j]] = 1;
			}
 		}
	}
	
	floyd();
	
	if (e[1][n] == 0x3f3f3f3f) cout << "NO";
	else cout << e[1][n] - 1;
	
	return 0;
}
1378：最短路径(shopth)
  • floyd
#include <bits/stdc++.h>
using namespace std;

int n, v0, e[100][100];

void floyd() {
	for (int k = 1; k <= n; k ++) 
		for (int i = 1; i <= n; i ++) 
			for (int j = 1; j <= n; j ++) 
				e[i][j] = min(e[i][j], e[i][k] + e[k][j]);
}

int main() {
	cin >> n >> v0;	
	for (int i = 1; i <= n; i ++) {
		for (int j = 1; j <= n; j ++) {
			string s;
			cin >> s;
			if (s == "-") {
				e[i][j] = 0x3f3f3f3f;
			}
			else {
				int t = 1;
				if (s[0] == '-') {
					t = -1;
					s = s.erase(0, 1);
				}
				
				int num = 0;
				for (int i = 0; i < s.size(); i ++) {
					num = num * 10 + s[i] - '0';
				}
				
				e[i][j] = num * t;
			}			
		}
	}
	
	floyd();

	for (int i = 1; i <= n; i ++) {
		if (i != v0) {
			printf("(%d -> %d) = %d\n", v0, i, e[v0][i]);
		}
	}

	return 0;
}
  • dijkstra不能处理负权边；
  • 虽然有负权边，但是无负环，所以可以用bellman_ford
#include <bits/stdc++.h>
using namespace std;

const int N = 100;
int n, m, v0;
int dis[N];

struct edge{
	int u, v, w;
}e[10000];

void bellman_ford() {
	memset(dis, 0x3f, sizeof(dis));
	dis[v0] = 0;
	
	for (int i = 1; i <= n; i ++) {
		for (int j = 1; j <= m; j ++) {
			int u = e[j].u, v = e[j].v, w = e[j].w;
			dis[v] = min(dis[v], dis[u] + w);
		}
	}	
}

int main() {
	scanf("%d%d", &n, &v0);
	
	for (int i = 1; i <= n; i ++) {
		for (int j = 1; j <= n; j ++) {
			char ch[10];
			scanf("%s", ch);
			if (strlen(ch) == 1 && ch[0] == '-') continue;
			e[++ m] = {i, j, atoi(ch)};
		}
	}

	bellman_ford();
	
	for (int i = 1; i <= n; i ++) {
		if (i != v0) {
			printf("(%d -> %d) = %d\n", v0, i, dis[i]);
		}
	}
	
	return 0;
}
1379：热浪(heatwv)
  • dijkstra
#include <bits/stdc++.h>
using namespace std;

const int N = 3000;
int t, c, ts, te;
int e[N][N];
bool vst[N];

void dijkstra() {
	vst[ts] = true;
	
	for (int i = 1; i < t; i ++) {
		int minn = 0;
		for (int j = 1; j <= t; j ++) {
			if (!vst[j] && e[ts][j] < e[ts][minn]) {
				minn = j;
			}
		}
		vst[minn] = true;
		
		for (int j = 1; j <= t; j ++) {
			if (!vst[j]) {
				e[ts][j] = min(e[ts][j], e[ts][minn] + e[minn][j]);
			}
		}
	}	
}

int main() {
	memset(e, 0x3f, sizeof(e));
	
	cin >> t >> c >> ts >> te;
	while (c --) {
		int u, v, w;
		cin >> u >> v >> w;
		e[u][v] = e[v][u] = w;
	}

	dijkstra();	
	printf("%d\n", e[ts][te]);
	
	return 0;
}
  • bellman_ford
#include <bits/stdc++.h>
using namespace std;

const int N = 3000, M = 14000;
int t, c, ts, te;
int dis[N];

struct edge{
	int u, v, w;
}e[M];

void bellman_ford() {
	memset(dis, 0x3f, sizeof(dis));
	dis[ts] = 0;
	
	for (int i = 1; i <= t; i ++) {
		for (int j = 1; j <= 2 * c; j ++) {
			int u = e[j].u, v = e[j].v, w = e[j].w;
			dis[v] = min(dis[v], dis[u] + w);
		}
	}	
}

int main() {
	scanf("%d%d%d%d", &t, &c, &ts, &te);
	
	for (int i = 1; i <= c; i ++) {
		int u, v, w;
		scanf("%d%d%d", &u, &v, &w);
		e[2 * i - 1] = {u, v, w};
		e[2 * i] = {v, u, w};
	}

	bellman_ford();
	printf("%d\n", dis[te]);
	
	return 0;
}
1381：城市路(Dijkstra)
  • 用dijkstra需要考虑重边
#include <bits/stdc++.h>
using namespace std;

const int N = 2010;
int n, m, e[N][N];
bool vst[N];

void dijkstra() {
	vst[1] = true;
	
	for (int i = 1; i < n; i ++) {
		int t = 0;
		for (int j = 1; j <= n; j ++) {
			if (!vst[j] && e[1][j] < e[1][t]) t = j;
		}
		vst[t] = true;
		
		for (int j = 1; j <= n; j ++) {
			if (!vst[j]) {
				e[1][j] = min(e[1][j], e[1][t] + e[t][j]);
			}
		}
	}
}

int main() {
	memset(e, 0x3f, sizeof(e));	
	
	cin >> n >> m;
	while (m --) {
		int u, v, w;
		cin >> u >> v >> w;
		e[u][v] = e[v][u] = min(e[u][v], w);
	}

	dijkstra();
	
	if (e[1][n] == 0x3f3f3f3f) puts("-1");
	else printf("%d", e[1][n]);
	
	return 0;
}
  • 用bellman_ford不用考虑重边
#include <bits/stdc++.h>
using namespace std;

const int N = 2010, M = 10010;
int n, m, dis[N];

struct edge{
	int u, v, w;
}e[M * 2];

int bellman_ford() {
	memset(dis, 0x3f, sizeof(dis));
	dis[1] = 0;
	
	for (int i = 1; i < n; i ++) {
		for (int j = 1; j <= 2 * m; j ++) {
			int u = e[j].u, v = e[j].v, w = e[j].w;
			dis[v] = min(dis[v], dis[u] + w);
		}
	}

	if (dis[n] == 0x3f3f3f3f) return -1;
	return dis[n];
} 

int main() {
	scanf("%d%d", &n, &m);
	
	for (int i = 1; i <= m; i ++) {
		int u, v, w;
		cin >> u >> v >> w;
		e[2 * i - 1] = {u, v, w};
		e[2 * i] = {v, u, w};
	}

	int t = bellman_ford();	
	printf("%d", t);
	
	return 0;
}
中学生信竞
关注
专栏目录
图论算法（一）--最短路径的DFS/BFS解法（JAVA ）
一串代码的博客
01-11 5737
最短路径–城市路径问题： 问题描述：求从1号城市到5号城市的最短路径长度 Input： 5 8 1 2 2 1 5 10 2 3 3 2 5 7 3 1 4 3 4 4 4 5 5 5 3 3 Output： 9 DFS import java.util.Scanner; public class minPath { static
图论-最短路径算法总结
zhimeng_LQ的博客
07-28 755
最短路问题 文章目录Dijkstra算法Dijkstra算法的策略 Dijkstra算法 Dijkstra算法：迪杰斯拉特拉算法 解决：单源最短路问题 特点：只能解决边权非负的问题，如果有负 推荐SPFA算法 给一个有向图和一个起点，通过算法求起点到每个顶点的最短距离。 Dijkstra算法的策略 设置集合S存放已被访问的顶点，然后执行①② 每次从集合(未被攻占)中选择与起点最短距离最小的点(记为U)，访问并加入集合(被攻占) 令顶点U为中介点，优化最短路 code for 邻接矩阵 int n,G[
矩阵和图结构(图论) 最短路径问题 学习笔记
qq_42244167的博客
01-25 267
矩阵和图是可以相互转换的,这里的图不仅仅是图片,还包括图结构(图论) 所以最短路径问题解决矩阵和结局图论均是一个问题.
【数据结构】图（五）—— 最短路径算法（二）—— Dijkstra Algorithm（迪杰斯特拉算法）
haoweixl的博客
02-28 1194
最短路径——迪杰斯特拉算法
最短路径算法（Floyd，Dijkstra，Blleman Ford）
m0_48630721的博客
03-19 583
最短路径算法
【信奥赛一本通】1381：城市路(Dijkstra)（详细代码）
qq_40802813的博客
03-25 2012
1381：城市路Dijkstra1.【题目描述】2.【Dijkstra算法】3.【代码】 1.【题目描述】 【题目描述】 【题目描述】 罗老师被邀请参加一个舞会，是在城市n，而罗老师当前所处的城市为1,附近还有很多城市2~n-1，有些城市之间没有直接相连的路，有些城市之间有直接相连的路，这些路都是双向的，当然也可能有多条。 现在给出直接相邻城市的路长度，罗老师想知道从城市1到城市n，最短多少距离。 【输入】 输入n, m，表示n个城市和m条路; 接下来m行，每行a b c， 表示城市a与城市b有长度为c的路
最短路径算法实现 k-shortest-paths
06-02
最短路径算法是图论中的一个经典问题，用于寻找网络中的两点之间具有最小成本或最短距离的路径。在计算机科学、交通规划、通信网络等领域都有广泛应用。k-Shortest Paths（k-最短路径）则是在这个基础上进一步扩展，...
哈工大数据结构与算法-图型结构的应用算法-最短路径算法的实现.zip
最新发布
06-02
在哈工大的数据结构与算法课程中，图型结构的应用算法是重要的研究...通过这个课程实验，学生不仅能掌握图论和最短路径算法的基本原理，还能提升编程能力和问题解决能力，为未来从事相关领域的研究或工作打下坚实基础。
基于Java的实例源码-最短路径算法实现 k-shortest-paths.zip
07-08
在IT领域，尤其是在图论和网络优化中，最短路径算法是一个重要的研究方向。这个"基于Java的实例源码-最短路径算法实现 k-shortest-paths.zip"压缩包文件提供了一个具体的Java实现，用于寻找图中的k条最短路径。下面...
php代码-最短路径算法1
07-15
总之，"php代码-最短路径算法1"是一个实践性质的学习资源，它让你有机会接触到图论、搜索算法以及PHP编程的实际应用，这些都是IT专业人员必备的技能。通过深入研究和实践，你可以提高自己的编程能力和解决问题的能力...
求两个城市之间的最短路径
06-24
数据结构课程设计：求两个城市之间的最短路径问题用c语言编写大家尽管用啊不必客气
城市道路规划
06-09
一个数据结构的课程设计，利用C++语言编写的算法。
信息学奥赛一本通 1381：城市路(Dijkstra)
君义NOIP的博客
03-07 1325
【题目链接】 ybt 1381：城市路(Dijkstra) 【题目考点】 1. 图论 单源最短路径 图中有V个顶点E条边，单源最短路径算法 时间复杂度： 朴素Dijkstra算法：O(V2)O(V^2)O(V2) Dijkstra堆优化算法：O(ElogE)O(ElogE)O(ElogE) SPFA算法：一般情况下O(kE)O(kE)O(kE)，k为顶点度（出度）的平均值，最坏情况下O(VE)O(VE)O(VE) 空间复杂度： 邻接矩阵：O(V2)O(V^2)O(V2) 邻接表：O(V+E)O(V+E
1381：城市路(Dijkstra)
与其邻渊羡渔，不如退而结网
08-24 673
【题目描述】罗老师被邀请参加一个舞会，是在城市n，而罗老师当前所处的城市为1,附近还有很多城市2~n-1，有些城市之间没有直接相连的路，有些城市之间有直接相连的路，这些路都是双向的，当然也可能有多条。现在给出直接相邻城市的路长度，罗老师想知道从城市1到城市n，最短多少距离。【输入】输入n, m，表示n个城市和m条路;接下来m行，每行a b c， 表示城市a与城市b有长度为c的路。【输出】输出1到n的最短路。如果1到达不了n，就输出-1。【输入样例】5 51 2 20。
7-19 单源点最短路(Dijkstra) (10分)
akyzz_15082282的博客
12-17 478
7-19 单源点最短路(Dijkstra) (10分) Y老师被邀请参加一个会议，是在城市n(n<=2000)，而Y老师当前所处的城市为1,附近还有很多城市2~n-1，有些城市之间没有直接相连的路，有些城市之间有直接相连的路，这些路都是双向的，当然也可能有多条。 现在给出直接相邻城市的路长度，Y老师想知道从城市1到城市n，最短多少距离。 输入格式: 输入n, m，表示n个城市和m(m<=100000)条路; 接下来m行，每行a b c， 表示城市a与城市b有长度为c(c<=1000)的路。
图论中最短路径算法详解——Floyd算法
"该资源是关于图论中最短路径问题的PPT，主要涉及图的存储、遍历、最短路算法，特别是Floyd算法的详细介绍。内容包括深度优先遍历（DFS）、广度优先遍历（BFS）、拓扑排序以及如何在有向无环图（DAG）中判断最短路径...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值