最短路算法—Bellman-Ford算法

Bellman-Ford算法

描述

• 迭代n次（实际意义，迭代k次之后不超过k条边的最短距离，若第n次迭代后有更新，抽屉原理可知存在负权环）
• 每次循环所有边a, b, w（表示从a到b的边，权重w）总共m次
• 存储边方式可任意，结构体存储，m个结构体
• 更新原理类似于Dijkstra算法
• 循环结束后，所有边满足三角不能式: dist[b] $\le$ dist[a] + w
• 若存在负权回路，最短路不存在。
• 时间复杂度O(n*m)

题目

853. 有边数限制的最短路

描述

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

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

输入格式

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

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

输出格式

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

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

数据范围

$1$ $\le$ $n,k$ $\le$ $500$

$1$ $\le$ $m$ $\le$ $10000$

变长绝对值不超过10000。

代码

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 510, M = 10010;

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

struct Edge {
    int a, b, w;
}edges[M];

int bellmanFord() {
    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 ++) {
            int a = edges[j].a;
            int b = edges[j].b;
            int w = edges[j].w;
            dist[b] = min(dist[b], backup[a] + w); 
        }
    }
    return dist[n];
}
int main() {
    scanf("%d%d%d", &n, &m, &k);
    
    for (int i = 0; i < m; i ++) {
        int a, b, w;
        scanf("%d%d%d", &a, &b, &w);
        edges[i] = {a, b, w};
    }
    int t = bellmanFord();
    // 正无穷最后会减小 但是不会减很多
    if (dist[n] > 0x3f3f3f / 2) 
        puts("impossible");
    else 
        printf("%d\n", t);
    return 0;
}

参考

1. 搜索与图论二