算法笔记——bellman_ford解决有负权值的图

整理一下最近学的图论算法，今天学到存在负权边的情况，先学一下Bellman-Ford算法；

bellman_ford算法适用于处理有负权边的图的最短路径，用一个结构体存储各个边，在规定的迭代次数里，一条一条地处理，以此不断更新dist数组。

题目：

给定一个n个点m个边的有向图，求1号到n号的最短距离；边权值可能为复负值，图可能有负权边

从1号到n号的最短距离最多经过k条边。

输入：n,m,k 然后后面是边和权值。

算法如下：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
//给定一个n个点m个边的有向图，求1号到n号的最短距离；
// 边权值可能为复负值，图可能有负权边
//从1号到n号的最短距离最多经过k条边

//输入：n,m,k 然后后面是边和权值

//用贝尔洛夫曼算法

const int N = 510, M = 10010;
int n, m, k;
int dist[N], backup[N];

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

int  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++)
        {
            int a = edges[j].a, b = edges[j].b, w = edges[j].w;
            dist[b] = min(dist[b], backup[a] + w);
            //这里不能dist[b] = min(dist[b], dist[a] + w)
        }
    }

    if (dist[n] > 0x3f3f3f / 2) return -1;
    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 = bellman_ford();

    if (t == -1) puts("impossible");
    else
        printf("%d\n", t);

    return 0;
}


/*
3 3 1
1 2 1
2 3 1
1 3 3
*/

注意：

这个图的所有边和权值都是由结构体定义的，也就是在算法进行时是一条边一条边来进行遍历的，并且由于最短路径的长度不能超过k。

如果是下图所示，且规定k=1，即从1到3的最短路径只能经过1条边，那么如果没有backup数组，则dist[b] = min(dist[b], dist[a] + w)，则将会如右上错误示范一样：

初始时dist[1]=0, dist[2] = dist[3]= 正无穷;

第一次迭代：

先看1到2这条边，dist[2] = min(dist[2], dist[1] + 1)=1;

再看2到3这条边，dist[3] = min(dist[3], dist[2] + 1)=2;

这样的话经过一次迭代之后，dist[3]的值依赖于dist[2]的变化而变化，违背了k=1的要求，所以错了。

因此，应该在每一次迭代都将上一次迭代得到的dist数组备份，每一次都在上一次迭代的基础上再做变化，即dist[b]=min(dist[b], backup[a] + w)，这样才能符合k的要求。