Bellman-Ford算法
题目
给定一个n个点m条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出从1号点到n号点的最多经过k条边的最短距离，如果无法从1号点走到n号点，输出impossible。
注意：图中可能 存在负权回路 。
输入格式
第一行包含三个整数n，m，k。
接下来m行，每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。
输出格式
输出一个整数，表示从1号点到n号点的最多经过k条边的最短距离。
如果不存在满足条件的路径，则输出“impossible”。
数据范围
1≤n,k≤500,
1≤m≤10000,
任意边长的绝对值不超过10000。
输入样例：
3 3 1
1 2 1
2 3 1
1 3 3
输出样例：
3
思路/大致模板：
*1 for n次
*2 每次 for 所有边 a —w-> b,（松弛操作）
(储存边的方式很广泛， 能走完所有边就可以了。）
*3 dist[b] = min(dist[b], dist[a] + w );
搞定！
循环后， 所有边一定满足 dist[b] <= dist[a] + w（三角不等式）
有负权回路的图不一定能求最短回路。
迭代n次的意义：
假设已经迭代了 k次， 那么dist[]数组的含义是从一号点 经过 不超过 k 条边走到每个点的最短距离。
时间复杂度 ： O(n*m）。
写法：
#include<bits/stdc++.h>
using namespace std;
const int N = 510, M = 100010;
int n, m, k;
int dist[N], backup[N];
struct Edge{
int a, b, w;
}e[M];
int brm(){
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
for(int i = 0; i < k; i ++){ /* *17 */
memcpy(backup, dist, sizeof dist); /* *18 */
for(int j = 0; j < m ; j ++){ /* *19 */
//取出a, b, w;
int a = e[j].a, b = e[j].b, w = e[j].w;
dist[b] = min(dist[b], backup[a] + w); /* *21 */
}
}
if(dist[n] > 0x3f3f3f3f / 2)/* *25 */
return -1;
return dist[n];
}
int main(){
cin >> n >> m >> k;
for(int i = 0; i < m; i ++){
int a, b, w;
cin >> a >> b >> w;
e[i] = {a, b, w};
}
int t = brm();
if(t == -1) cout << "impossible" << endl;
else cout << t;
return 0;
}
/*bellman-ford 可以求出当经过的边不超过k条时的单源最短路。
*17 所以这里 0 <= i < k, 一共k次。
*18 备份上一轮的图；
*19 j将所有的边都遍历一遍；
*21 为了不 串联(这一轮走了两条边， 但理论上一轮只应该走一条边)，就要用上一轮的图；
新的数据会保留在新的图里，当所有的边都遍历完之后再复制回去
*25 假设 1没有边可以经过5、8,dist[5]、dist[8]都是10^9(正无穷),
但是5到8的距离是2，那么dist[8]会被更新为 10^9-2, 就不再是正无穷。
题目所限制的距离一般不会超过0x3f3f3f3f的一半。
*/
我在这里重新整理了一下这个算法，感觉比这个版本的注释好一点……
————————————————————
SPFA算法
spfa求最短路
思路
优化Bellman-Ford
对Bellman-Ford算法 中的dist[b] = min(dist[b], dist[a] + w )做优化。
因为dist[a]不一定会更新dist[b]。具体而言就是，当dist[a]变小了， 与其相连的dist[b]才会变小。
用宽搜做优化。
大致模板
*1 定义一个queue q， 用来储存dist变小了的点；
*2 while q 不空
*3 取出队头 t，pop(t);
*4 更新 t 的所有出边。
*5 如果更新成功 且 队列中没有b， 将 b 入队；
写法和Dijkstra算法很像,不过是把针对“点”的操作 改为 针对“边”的操作。
注：很多正权图可以用SPFA。
例题
给定一个n个点m条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出1号点到n号点的最短距离，如果无法从1号点走到n号点，则输出impossible。
数据保证不存在负权回路。
输入格式
第一行包含整数n和m。
接下来m行每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。
输出格式
输出一个整数，表示1号点到n号点的最短距离。
如果路径不存在，则输出”impossible”。
数据范围
1≤n,m≤105,
图中涉及边长绝对值均不超过10000。
输入样例：
3 3
1 2 5
2 3 -3
1 3 4
输出样例：
2
#include<bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m;
int dist[N];
int ne[N], h[N], e[N], w[N], idx = 0;
bool st[N];
void add(int a, int b, int c){
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
int spfa(){
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
st[1] = 1;
queue<int> q;
q.push(1);
while(q.size()){
int t = q.front();
q.pop();
st[t] = 0;
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(!st[j]){
st[j] = 1;
q.push(j);
}
}
}
}
if(dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
int main(){
cin >> n >> m;
memset(h, -1, sizeof h);
for(int i = 0; i < m; i ++){
int a, b, c;
cin >> a >> b >> c;
add(a, b, c);
}
int t = spfa();
if(t == -1) cout << "impossible";
else cout << t;
return 0;
}
————————————————————————————————————
spfa判断负环
好处：一般用SPFA判断负环 可以解决有负权的问题，效率比Disjktra高
坏处：容易被出题人卡
思路
原理：抽屉原理。
如果在某一次 cnt[x] >= n , 就说明从1到x至少经过了n条边
那就代表从1到x至少经过了n+1个点
一共只有n个点，那么一定有两个点是相同的，那就出现环了，而且是负权
在更新 dist数组 时，dist数组 表示的是当前从一号点到其它点的最短路径的长度
同时用 cnt[x]数组 来记录从1到当前点 x 的最短路所经过的边数
dist[x] = dist[t] + w[i];
cnt[x] = cnt[t] + 1;
例题
ACwing 852. spfa判断负环
题目
提交记录
讨论
题解
视频讲解
给定一个n个点m条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你判断图中是否存在负权回路。
输入格式
第一行包含整数n和m。
接下来m行每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。
输出格式
如果图中存在负权回路，则输出“Yes”，否则输出“No”。
数据范围
1≤n≤2000,
1≤m≤10000,
图中涉及边长绝对值均不超过10000。
输入样例：
3 3
1 2 -1
2 3 4
3 1 -4
输出样例：
Yes
#include<bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m;
int dist[N], cnt[N];
int ne[N], h[N], e[N], w[N], idx = 0;
bool st[N];
void add(int a, int b, int c){
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
int spfa(){
memset(dist, 0x3f, sizeof dist);
dist[1] = 0; /* *17 */
queue<int> q;
for(int i = 1; i <= n; i ++){ /* *19 */
st[i] = 1;
q.push(i);
}
while(q.size()){
int t = q.front();
q.pop();
st[t] = 0;
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];
cnt[j] = cnt[t] + 1;
if(cnt[j] >= n) return 1;
if(!st[j]){
st[j] = 1;
q.push(j); /* 别漏了*/
}
}
}
}
return 0;
}
int main(){
cin >> n >> m;
memset(h, -1, sizeof h);
for(int i = 0; i < m; i ++){
int a, b, c;
cin >> a >> b >> c;
add(a, b, c);
}
if(spfa()) cout << "Yes";
else cout << "No";
return 0;
}
/*
*17 可以不用初始化，因为不用求最短路距离，只要有dist来辅助判断是否有负环就可以了。
*19 所有点都要spfa一遍， 因为从1开始并不一定能找到负环！一开始将所有点放进队列中。
*/