#Bellman-Ford最短路算法 #SPFA(spfa)算法 2020.08.14

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。

例题

Acwing 851. 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开始并不一定能找到负环！一开始将所有点放进队列中。
*/