Floyd,Dijkstra,SPFA模板整理(以[HDU2544-最短路]为例 )

最新推荐文章于 2021-08-15 16:48:48 发布

原创最新推荐文章于 2021-08-15 16:48:48 发布 · 407 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#最短路 #dijkstra #Floyd #链式前向星 #spfa

数据结构与算法同时被 2 个专栏收录

3 篇文章

订阅专栏

图论---最短路

1 篇文章

订阅专栏

本文实战演示了四种经典的最短路径算法：SPFA结合链式前向星、Dijkstra结合邻接矩阵、Dijkstra结合堆优化以及Floyd结合邻接矩阵。通过对一道基本最短路径问题的求解，展示了各种算法的实现细节。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

复习了一下三大基础最短路算法

随说只有三种,但实际上由于情况不同,

有Dijkstra,Dijkstra-堆优化,SPFA-邻接矩阵,SPFA-链式前向星,Floyd-邻接矩阵,Floyd-邻接表等更多种写法...

至于Bellmen-Ford算法.SPFA就是它的队列优化形式,不再赘述.

用一道最基本的最短路算法问题来写一下我常用的四种吧.

原题链接:http://acm.split.hdu.edu.cn/showproblem.php?pid=2544

_____________

Time limit: 1000 msMemory limit: 32768 kBOS: Windows

Input

输入包括多组数据。每组数据第一行是两个整数N、M（N<=100，M<=10000），N表示节点数目，标号为1为源节点，标号为N为汇节点，M为边的数目.

N=M=0表示输入结束。接下来M行，每行包括3个整数A，B，C（1<=A,B<=N,1<=C<=1000）,表示在节点A与节点B之间有一条双向边，经过一次该边的花费是C。
输入的图保证至少有1条从源点到汇点的路径。

Output

对于每组输入，输出一行,含有一个数字，表示从源点到汇点的最小花费

_____________

Sample Input

Sample Output

3
2

_____________

(所有代码已通过全部测试数据)

spfa + 链式前向星:

/**********************
*@Name: hdu 2544 spfa
*
*@Author: Nervending
*@Describtion: spfa link 
*@DateTime: 2017-10-04 14:00:39
***********************/
#include <queue>
#include <string.h>
#include <iostream>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 1e4 + 100;
const int INF = 0x3f3f3f3f;
const int DINF = 0xc0c0c0c0;
int a, b, c;
int n, m, k, T;
int t, ans;
int x, y, z;
struct node {
	int to, cost, next;
} e[maxn];
int head[maxn];
bool vis[maxn];
int dis[maxn], nume;
void init() {
	memset(e, 0, sizeof e);
	memset(head, -1, sizeof head);
	memset(vis, false, sizeof vis);
	memset(dis, 0x3f, sizeof dis);
	ans = 0;
	nume = 0;
}
void add(int a, int b , int c) {
	node t = {b, c, head[a]};
	e[nume] = t;
	head[a] = nume++;
}
void spfa(int st, int ed) {
	queue <int> q;
	q.push(st);
	dis[st] = 0;
	while (!q.empty()) {
		int now = q.front();
		q.pop();
		vis[now] = false;
		for (int i = head[now]; ~i; i = e[i].next) {
			int to = e[i].to;
			int cost = e[i].cost;
			if (dis[to] > dis[now] + cost) {
				dis[to] = dis[now] + cost;
				if (!vis[to]) {
					vis[to] = true;
					q.push(to);
				}
			}
		}
	}
	ans = dis[ed];
}

int main() {

	while (cin >> n >> m, n || m) {
		init();
		for (int i = 0; i < m; i++) {
			cin >> a >> b >> c;
			add(a, b, c);
			add(b, a, c);
		}
		spfa(1, n);
		cout << ans << endl;
	}
	return 0;
}

dijkstra+邻接矩阵

/**********************
*@Name: hdu 2544 dijkstra
*
*@Author: Nervending
*@Describtion: Dijkstra
*@DateTime: 2017-10-04 14:00:39
***********************/
#include <string.h>
#include <iostream>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 1e2 + 10;
const int INF = 0x3f3f3f3f;
const int DINF = 0xc0c0c0c0;
int a, b, c;
int n, m, k, T;
int t, ans;
int x, y, z;
int cost[maxn][maxn];
bool vis[maxn];
int dis[maxn];

void init() {
	fill(dis, dis + maxn, INF);
	fill(vis, vis + maxn, false);
	memset(cost, INF, sizeof cost);
	ans = 0;
}

void dijkstra(int st, int ed) {
	for (int i = 1; i <= n; i++) {
		cost[i][i] = 0;
		dis[i] = cost[st][i];
	}
	vis[st] = true;
	int now;
	// dis[st]=0;
	for (int i = 1; i <= n; i++) {
		int mini = INF;
		for (int j = 1; j <= n; j++) {
			if (vis[j] == 0 && dis[j] < mini) {
				now = j;
				mini = dis[j];
			}
		}
		vis[now] = 1;
		for (int j = 1; j <= n; j++) {
			if (vis[j] == 0)
				if (cost[now][j] < INF && dis[now] + cost[now][j] < dis[j])
					dis[j] = dis[now] + cost[now][j];
		}
	}
	ans = dis[ed];
}


int main() {

	while (cin >> n >> m, n || m) {
		init();
		for (int i = 0; i < m; i++) {
			cin >> a >> b >> c;
			cost[a][b] = cost[b][a] = c;
		}
		dijkstra(1, n);
		printf("%d\n", ans);
	}
}

dijkstra + heap

/**********************
*@Name: hdu 2544 dijkstra heap
*
*@Author: Nervending
*@Describtion: Dijkstra  heap
*@DateTime: 2017-10-04 14:00:39
***********************/
#include <queue>
#include <string.h>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 1e2 + 10;
const int INF = 0x3f3f3f3f;
const int DINF = 0xc0c0c0c0;
int a, b, c;
int n, m, k, T;
int t, ans;
int x, y, z;

vector<pair<int, int>> e[maxn];
int dis[maxn];
bool vis[maxn];

void init() {
	for (int i = 0; i < maxn; i++) e[i].clear();
	memset(dis, INF, sizeof dis);
	ans = 0;
}

void dijkstra(int st, int ed) {
	priority_queue<pair<int, int> > q;
	q.push(make_pair(-INF, st));
	dis[st] = 0;
	while (!q.empty()) {
		int now = q.top().second;
		q.pop();
		int size = e[now].size();
		for (int i = 0; i < size; i++) {
			int to = e[now][i].first;
			int cost = e[now][i].second;
			if (dis[to] > dis[now] + cost) {
				dis[to] = dis[now] + e[now][i].second;
				q.push(make_pair(-dis[to], to));
			}
		}
	}
	ans = dis[ed];
}

int main() {

	while (cin >> n >> m, n || m) {
		init();
		for (int i = 0; i < m; i++) {
			cin >> a >> b >> c;
			e[a].push_back(make_pair(b, c));
			e[b].push_back(make_pair(a, c));

		}
		dijkstra(1, n);
		cout << ans << endl;
	}
}

Floyd+邻接矩阵

/**********************
*@Name: hdu 2544 Floyd
*
*@Author: Nervending
*@Describtion: Floyd
*@DateTime: 2017-10-04 14:00:39
***********************/
#include <string.h>
#include <iostream>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 1e2 + 10;
const int INF = 0x3f3f3f3f;
const int DINF = 0xc0c0c0c0;
int a, b, c;
int n, m, k, T;
int t, ans;
int x, y, z;
int dis[maxn][maxn];

void init() {
	memset(dis, INF, sizeof dis);
	for (int i = 0; i < maxn; i++) {
		dis[i][i] = 0;
	}
	ans = 0;
}

void floyd(int st , int ed) {
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			for (int k = 1; k <= n; k++) {
				if (dis[j][k] > dis[j][i] + dis[i][k]) {
					dis[j][k] = dis[j][i] + dis[i][k];
				}
			}
		}
	}
	ans = dis[st][ed];
}

int main() {
	while (cin >> n >> m, n || m) {
		init();
		for (int i = 0; i < m; i++) {
			cin >> a >> b >> c;
			dis[a][b] = dis[b][a] = c;
		}
		floyd(1, n);
		cout << ans << endl;
	}
}