bellman-ford算法，有限制边数的最短路问题（可含负权边）

bellman_ford算法用于解决：　

• 有边数限制的最短路问题
• 可以用来判断是否有负环

什么是bellman - ford算法？

Bellman - ford 算法是求含负权图的单源最短路径的一种算法，效率较低，代码难度较小。其原理为连续进行松弛，在每次松弛时把每条边都更新一下，若在 n-1 次松弛后还能更新，则说明图中有负环，因此无法得出结果，否则就完成。
(通俗的来讲就是：假设 1 号点到 n 号点是可达的，每一个点同时向指向的方向出发，更新相邻的点的最短距离，通过循环 n-1 次操作，若图中不存在负环，则 1 号点一定会到达 n 号点，若图中存在负环，则在 n-1 次松弛后一定还会更新)　　

时间复杂度为O(mn)

bellman - ford算法的具体步骤

for k次
for 所有边 a,b,w (松弛操作)
dist[b] = min(dist[b],back[a] + w)

注意：

• backup[] 数组是上一次迭代后 dist[] 数组的备份，由于是每个点同时向外出发，因此需要对 dist[] 数组进行备份，若不进行备份会因此发生串联效应，影响到下一个点
• 在下面代码中，是否能到达n号点的判断中需要进行if(dist[n] > INF/2)判断，而并非是if(dist[n] == INF)判断，原因是INF是一个确定的值，并非真正的无穷大，会随着其他数值而受到影响，dist[n]大于某个与INF相同数量级的数即可

模板题：

给定一个 n">n 个点 m">m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出从 1">1 号点到 n">n 号点的最多经过 k">k 条边的最短距离，如果无法从 1">1 号点走到 n">n 号点，输出 impossible。

注意：图中可能 存在负权回路 。

输入格式

第一行包含三个整数 n,m,k">n,m,k。

接下来 m">m 行，每行包含三个整数 x,y,z">x,y,z，表示存在一条从点 x">x 到点 y">y的有向边，边长为 z">z。

输出格式

输出一个整数，表示从 1">1 号点到 n">n 号点的最多经过 k">k 条边的最短距离。

如果不存在满足条件的路径，则输出 impossible。

数据范围

1≤n,k≤500">1≤n,k≤500
1≤m≤10000">1≤m≤10000,
任意边长的绝对值不超过 10000">10000。

输入样例：

3 3 1
1 2 1
2 3 1
1 3 3

输出样例：

3

#include 
#include 
using namespace std;
const int N = 510, M = 10010;
struct Edge
{
    int a, b, c;
}edge[M];

int n, m, k;
int dist[N], backup[N];

void bellman_ford()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    for(int i = 0; i < k; i++)
    {
        memcpy(backup, dist, sizeof dist);
        for(int j = 0; j < m; j++)
        {
            auto t = edge[j];
            dist[t.b] = min(dist[t.b], backup[t.a] + t.c);
        }
    }
}
int main()
{
    cin >> n >> m >> k;
    
    for(int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        edge[i] = {a, b, c};
    }
    
    bellman_ford();
    
    if(dist[n] > 0x3f3f3f3f / 2) puts("impossible");
    else cout << dist[n] << endl;
    
    return 0;
}

当然，也可以用bellmanford算法求单源最短路问题，我个人认为比dijstra简单一点，但是时间复杂度很高，所以只能说是有时候可以用。

如：

给定一个 n">n 个点 m">m 条边的有向图，图中可能存在重边和自环，所有边权均为正值。

请你求出 1">1 号点到 n">n 号点的最短距离，如果无法从 1">1 号点走到 n">n 号点，则输出 −1">?1。

输入格式

第一行包含整数 n">n 和 m">m。

接下来 m">m 行每行包含三个整数 x,y,z">x,y,z，表示存在一条从点 x">x 到点 y">y 的有向边，边长为 z">z。

输出格式

输出一个整数，表示 1">1 号点到 n">n 号点的最短距离。

如果路径不存在，则输出 −1">?1。

数据范围

1≤n≤500">1≤n≤500
1≤m≤105">1≤m≤10^5
图中涉及边长均不超过10000。

输入样例：

3 3
1 2 2
2 3 1
1 3 4

输出样例：


用bellmanford算法求最短路的时候，就不需要backup备份了，注意。

#include 
#include 
using namespace std;
const int N = 510, M = 100010;
struct Edge
{
    int a, b, c;
}edge[M];
int n, m, dist[N];

void bellman_ford()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < m; j++)
        {
            auto t = edge[j];
            dist[t.b] = min(dist[t.b], dist[t.a] + t.c);
        }
    }
}
int main()
{
    cin >> n >> m;
    for(int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        edge[i] = {a, b, c};
    }
    bellman_ford();
    
    if(dist[n] > 0x3f3f3f3f / 2) cout << -1 << endl;
    else cout << dist[n] << endl;
    
    return 0;
}