Floyd Dijkstra Bellman-Ford spfa 四种最短路经典算法汇总 HDU 2544为例
来源:互联网 发布:stm32单片机arm的区别 编辑:程序博客网 时间:2024/06/03 22:38
Floyd Dijkstra Bellman-Ford spfa 四种最短路经典算法汇总
最短路
Problem Description
在每年的校赛里,所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候,却是非常累的!所以现在他们想要寻找最短的从商店到赛场的路线,你可以帮助他们吗?
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条商店到赛场的路线。
输入保证至少存在1条商店到赛场的路线。
Output
对于每组输入,输出一行,表示工作人员从商店走到赛场的最短时间
Sample Input
2 11 2 33 31 2 52 3 53 1 20 0
Sample Output
32
No. 1 Floyd
#include <bits/stdc++.h>#define endl "\n"#define inf 0x7fffffffusing namespace std;const int MAXN = 100 + 7;int n, m;int dis[MAXN][MAXN];void Init() { for(int i = 0; i <= n; ++i) { for(int j = 0; j <= n; ++j) { i == j ? dis[i][j] = 0 : dis[i][j] = inf; } }}int main(){ ios::sync_with_stdio(false); while(cin >> n >> m) { if(!n && !m) break; Init(); int u, v, w; for(int i = 1; i <= m; ++i) { cin >> u >> v >> w; dis[u][v] = min(w, dis[u][v]); dis[v][u] = min(w, dis[v][u]); } /************************************** * Floyd O(n^3) * 三行情书, for 循环中i, j, k * 顺序不能变(k) * 本质是动态规划,枚举状态,转移 **************************************/ for(int k = 1; k <= n; ++k) { for(int i = 1; i <= n; ++i) { for(int j = 1; j <= n; ++j) { if(dis[i][k] < inf && dis[k][j] < inf && dis[i][j] > dis[i][k] + dis[k][j]) { dis[i][j] = dis[i][k] + dis[k][j]; } } } } cout << dis[1][n] << endl; } return 0;}
No. 2 Dijkstra
/********************************************************** * 最短路Dijkstra算法 O(n^2) * 适用于求单源最短路,不适合带有负权的情形 * 算法思想:从原点出发,每次找一个源点能到达的最短路 * 径并找到该点将其标号,再从源点开始将所有 * 点的距离依照 * dis[j] > dis[index] + gra[index][j] * 更新 * 基于:最短路的子路也一定是最短路 *********************************************************/#include <bits/stdc++.h>#define endl "\n"#define inf 0x7ffffffusing namespace std;const int MAXN = 100 + 7;int n, m;int dis[MAXN], vis[MAXN], gra[MAXN][MAXN];void Init() { for(int i = 0; i <= n; ++i) { vis[i] = 0; for(int j = 0; j <= n; ++j) { gra[i][j] = inf; } }}void Dijkstra(int u) { int mindis = inf, index; vis[u] = 1, dis[u] = 0; for(int i = 1; i <= n; ++i) { dis[i] = gra[u][i]; } for(int i = 1; i <= n; ++i) { mindis = inf; for(int j = 1; j <= n; ++j) { if(!vis[j] && dis[j] < mindis) { mindis = dis[j]; index = j; } } vis[index] = 1; for(int j = 1; j <= n; ++j) { if(!vis[j] && dis[index] + gra[index][j] < dis[j]) { dis[j] = dis[index] + gra[index][j]; } } }}int main(){ ios::sync_with_stdio(false); while(cin >> n >> m) { if(!n && !m) break; Init(); int u, v, w; for(int i = 0; i < m; ++i) { cin >> u >> v >> w; gra[u][v] = min(gra[u][v], w); gra[v][u] = min(gra[v][u], w); } Dijkstra(1); cout << dis[n] << endl; } return 0;}
/******************************************************* * Bellman-Ford O(V*E) * 使用条件更广泛,可处理带环,负权,负环的问题 * 可求得单元最短路并求出路径反向输出 * 算法伪码: * BELLMAN-FORD(G, w, s) * 1 INITIALIZE-SINGLE-SOURCE(G, s) * 2 for i ← 1 to |V[G]| - 1 // 最多n-1次松弛 * 3 do for each edge (u, v) ∈ E[G] * 4 do RELAX(u, v, w) * 5 for each edge (u, v) ∈ E[G] * 6 do if d[v] > d[u] + w(u, v) * 7 then return FALSE * 8 return TRUE * 算法思想: * 首先初始化所有dis[i] = inf * 对于每一条边e(u, v), * 如果 * dis[u] + w(u, v) < dis[v] * 则令 * dis[v] = dis[u]+w(u, v) * w(u, v)为边e(u,v)的权值; * 为了检测图中是否存在负环路,即权值之和小于0的环路。 * 松弛完成后,对于每一条边e(u, v),如果存在 * dis[u] + w(u, v) < dis[v]的边, * 则图中存在负环路,即是说该图无法求出单源最短路径。 * 否则数组dis[n]中记录的就是源点s到各顶点的最短路径长度。 * * PS:无向图可用反向建边的方式 * ******************************************************/#include <bits/stdc++.h>#define endl "\n"#define inf 0x7fffffffusing namespace std;const int MAXN = 100 + 7;struct Edge { int u, v, w;}edge[MAXN * MAXN * 2];int dis[MAXN], n, m;void Init() { for(int i = 1; i <= 2*m; ++i) { edge[i].w = inf; } for(int i = 0; i <= n; ++i) { dis[i] = inf; }}bool BellmanFord(int u) { dis[u] = 0; for(int i = 1; i < n; ++i) { for(int j = 1; j <= 2*m; ++j) { if(dis[edge[j].u] < inf) { dis[edge[j].v] = min(dis[edge[j].v], dis[edge[j].u] + edge[j].w); } } } bool flag = true; for(int i = 1; i <= 2*m; ++i) { if(dis[edge[i].v] > dis[edge[i].u] + edge[i].w) { flag = false; break; } } return flag;}int main(){ ios::sync_with_stdio(false); while(cin >> n >> m) { if(!n && !m) break; Init(); int u, v, w; for(int i = 1; i <= m; ++i) { cin >> u >> v >> w; edge[i].u = u; edge[i].v = v; //cout << edge[i].w << endl; edge[i].w = min(w, edge[i].w); edge[i+m].u = v; edge[i+m].v = u; edge[i+m].w = min(w, edge[i+m].w); } BellmanFord(1); cout << dis[n] << endl; } return 0;}
No. 4 Spfa (亦即优化的Bellman-Ford)
/******************************************************* * spfa O(k * E) (k 一般 <= 2) * 算法思想:spfa其实就是改进的Bellman-Ford * 这里将由i发出的能直接到达的点存放在 * link[i]里,用bfs进行松弛操作,将在队 * 列里面的点标记,每次将队首元素出列, * 根据link[v]遍历与v连接的点并进行松弛 * 操作,遍历完所有点后就得到了最短路(存在) * 再开一个cnt数组,cnt[i]表示i进入队列 * 的次数,当i>n时,存在负环,无最短路 ******************************************************/#include <bits/stdc++.h>#define endl "\n"#define inf 0x7fffffff // 注意inf的条件using namespace std;const int MAXN = 100 + 7;int gra[MAXN][MAXN], vis[MAXN], dis[MAXN], cnt[MAXN];vector< vector<int> > link(MAXN); // link[i]中存由i能直接到达的点的编号int n, m;void Init() { for(int i = 0; i < MAXN; ++i) { // 多重vector不能直接link.clear() link[i].clear(); } for(int i = 0; i <= n; ++i) { dis[i] = inf; cnt[i] = vis[i] = 0; } for(int i = 0; i <= n; ++i) { for(int j = 0; j <= n; ++j) { i == j ? gra[i][j] = 0 : gra[i][j] = inf; } }}bool spfa(int u) { dis[u] = 0; cnt[u] = vis[u] = 1; // vis代表在不在队列内 queue<int> q; q.push(u); while(!q.empty()) { int v = q.front(); vis[v] = 0; // 每次队首元素出队列就将vis[v]置零 q.pop(); for(int i = 0; i < link[v].size(); ++i) { // 由v指向的所有点进行松弛操作 if(dis[v] < inf && dis[link[v][i]] > dis[v] + gra[v][link[v][i]]) { dis[link[v][i]] = dis[v] + gra[v][link[v][i]]; if(!vis[link[v][i]]) { q.push(link[v][i]); vis[link[v][i]] = 1; cnt[link[v][i]]++; if(cnt[link[v][i]] > n) return false; // 存在负环 } } } } return true;}int main(){ ios::sync_with_stdio(false); while(cin >> n >> m) { if(!n && !m) break; Init(); int u, v, w; for(int i = 1; i <= m; ++i) { cin >> u >> v >> w; gra[u][v] = min(w, gra[u][v]); // 无向图反向建边 gra[v][u] = min(w, gra[v][u]); link[u].push_back(v); link[v].push_back(u); } spfa(1); cout << dis[n] << endl; } return 0;}
0 0
- Floyd Dijkstra Bellman-Ford spfa 四种最短路经典算法汇总 HDU 2544为例
- 模板--Floyd Dijkstra Bellman-Ford spfa 四种最短路经典算法
- HDU-#2544 最短路(Dijkstra、Floyd、Bellman-Ford、SPFA)
- hdu-2544-最短路-(bellman-ford、dijkstra、floyd、SPFA算法)
- HDU 2544(Floyd、Dijkstra、Bellman-Ford、SPFA)
- hdu-2544-最短路(Dijkstra + Dijkstra优先队列 + Bellman-ford + SPFA +Floyd) 纯模板题
- HDU 2544 最短路(四种写法:Floyd、Dijkstra、Bellman-Ford、SPFA)
- Dijkstra、Bellman-ford、SPFA、Floyd算法
- 最短路算法 Dijkstra Bellman-Ford SPFA
- hdu 2544 最短路(Floyd-Warshal,Dijkstra,bellman-ford)
- 最短路算法 :Bellman-ford算法 & Dijkstra算法 & floyd算法 & SPFA算法 详解
- 最短路算法 :Bellman-ford算法 & Dijkstra算法 & floyd算法 & SPFA算法 详解
- 最短路算法 :Bellman-ford算法 & Dijkstra算法 & floyd算法 & SPFA算法 详解
- 最短路算法 :Bellman-ford算法 & Dijkstra算法 & floyd算法 & SPFA算法详解&BFS
- 最短路(SPFA、Dijkstra、Floyd、Bellman-Ford)
- 最短路知识点总结(Dijkstra,Floyd,SPFA,Bellman-Ford)
- 最短路模板Dijkstra Bellman-Ford Floyd SPFA
- 最短路知识点总结(Dijkstra,Floyd,SPFA,Bellman-Ford)
- 【unity3d-C#学习笔记】C#中常用的数据结构及遍历方法
- Linux环境下安装python3
- 虚拟机实现代码
- 表达式计算——by Java
- 简单的GCC语法: 弄清gcc test.c 与 gcc -c test.c 的差别
- Floyd Dijkstra Bellman-Ford spfa 四种最短路经典算法汇总 HDU 2544为例
- Java中CAS详解-待学习的任务
- 7. Reverse Integer Add to List★
- Activity的四种启动模式简介
- 分别用javascript,jquery实现 对图片的放大镜效果
- 逗号代码,字符图片网格-用Python自动化无聊的东西-chapter4
- 值得纪念的一次家庭晚餐
- L1-1出生年
- php的运行原理、cgi对比fastcgi以及php-cgi和php-fpm之间的联系区别