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

[align=left]复习了一下三大基础最短路算法[/align]
[align=left]随说只有三种,但实际上由于情况不同,[/align]
[align=left]有Dijkstra,Dijkstra-堆优化,SPFA-邻接矩阵,SPFA-链式前向星,Floyd-邻接矩阵,Floyd-邻接表等更多种写法...[/align]
[align=left]至于Bellmen-Ford算法.SPFA就是它的队列优化形式,不再赘述.
[/align]
[align=left]用一道最基本的最短路算法问题来写一下我常用的四种吧.[/align]
[align=left]原题链接:http://acm.split.hdu.edu.cn/showproblem.php?pid=2544[/align]
[align=left]_____________
[/align]

Time limit:          1000 msMemory limit:     32768 kBOS:                      Windows
[align=left]Input[/align]
输入包括多组数据。每组数据第一行是两个整数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条从源点到汇点的路径。
[align=left]Output[/align]
对于每组输入，输出一行,含有一个数字，表示从源点到汇点的最小花费
_____________

[align=left]Sample Input[/align]

2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0

[align=left]Sample Output[/align]

32

_____________

 (所有代码已通过全部测试数据)
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;
}
}