Bellman-Ford，解决最短路径的负权边问题

通过Dijkstra算法找到了最短路径后，我就先出发去往了2号城市。在当地一个公园观景时遇到了我的大学同学枇伊，她就住在2号城市，也正好在公园里闲逛。见面寒暄时，我说起了来的原因，顺便讲了我用Dijkstra算法求最短路径的事，这一下可引起了我这爱好算法的同学的兴趣，她马上说到：”那你有没有想过要是出现了负权边，Dijkstra算法是解决不了的，你有没有别的对策了呀“。我陷入沉思(懵逼)。

一.基本思想

”现在让我把你设计的图改下，让它有一条负权边。就像下图这样吧。

2->3之间的边权现在成了负值，该怎么办呢？

1. 首先我们要做一下初始化，和Dijkstra算法的区别主要有两点，一是dist数组开始时除了源点之外的其它所有结点都设置成无限大，二是不需要再设置用来表示集合的数组了。
2. 最核心的算法和Dijkstra一样，都是计算dist[j]>dist[i]+map[i] [j]，如果条件成立，则dist[j]=dist[i]+map[i] [j]，就是更新的操作，也叫“松弛”。Bellman-Ford算法中，如果图上有n个结点，至多会有n-1轮的“松弛”，每轮“松弛”会将m条边都遍历一遍。刚开始的时候，不用管4，5这样“前不着村，后不着店”的城市结点，主要看2，3这样和源点1号城市(假设是源点)直接相邻的结点，它们开始时都是无穷大，经过一次比较就“松弛”成了dist[2]=3,dist[3]=4。其它与2，3相连的结点如果在之后被计算并比较的话，同样会“松弛”，但是如果在前面被遍历的话，对应的dist数组单元中的值为无穷大，无法启动“松弛”。Bellman-Ford算法是通过相邻结点的计算不断扩展的，2，3结点作为源点的邻居“松弛”，下一轮2，3的邻居结点4，5就会被计算并比较，完成“松弛”。
3. 每一轮之后都至少有一个结点被求出了最短路径，所以当图上有n个结点时，要排除源点本身，最多会有n-1轮。

最后提一下，这个算法是由Bellman和Ford发明的，一般来说就叫Bellman-Ford算法，也可以叫Moore-Bellman-Ford 算法。“她这样说到。

二.代码

测试样例

5 7
1 2 3
1 3 4
2 3 -2
3 5 2
2 5 1
2 4 7
4 5 5
1

java版

import java.util.Scanner;

public class Bellman_Ford {
    static int MAXN=1000;
    static int INF=Integer.MAX_VALUE;
    static int[][] map=new int[MAXN][MAXN];
    static int[] dist=new int[MAXN];
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n,m,from,to,weight,source;
        n=sc.nextInt();
        m=sc.nextInt();
        init(n);
        while(m-->0){
            from=sc.nextInt();
            to=sc.nextInt();
            weight=sc.nextInt();
            map[from][to]=weight;
        }
        source=sc.nextInt();
        dist[source]=0;
        for (int num = 1;num <= n - 1;num++)
        {
            for (int i = 1;i <= n;i++)
            {
                for (int j = 1;j <= n;j++)
                {
                    if (map[i][j] < INF)
                    {
                        if (dist[j] > dist[i] + map[i][j])
                        {
                            dist[j] = dist[i] + map[i][j];
                        }
                    }
                }
            }
        }
        for(int k=1;k<=n;k++){
            System.out.println(dist[k]);
        }
    }
    private static void init(int n){
        for(int i=1;i<=n;i++){
            dist[i]=INF;
        }
        for (int i = 1;i < MAXN;i++)
        {
            for (int j = 1;j < MAXN;j++)
            {
                if (i == j)map[i][j] = 0;
                else map[i][j] = INF;
            }
        }
    }
}

C++版

#include<stdio.h>
#include<iostream>
#include<algorithm>
using namespace std;
const int MAXN = 1000;
const int INF = 999;
int map[MAXN][MAXN];
int dist[MAXN];
void init()
{
	for (int i = 1;i < MAXN;i++)
	{
		for (int j = 1;j < MAXN;j++)
		{
			if (i == j)map[i][j] = 0;
			else map[i][j] = INF;
		}
	}
}
int main()
{
	int n, m, u, v, w, source;
	init();
	scanf("%d %d", &n, &m);
	for (int i = 1;i <= n;i++)
		dist[i] = INF;
	while (m--)
	{
		scanf("%d %d %d", &u, &v, &w);
		map[u][v] = w;
	}
	scanf("%d", &source);
	dist[source] = 0;
	for (int num = 1;num <= n - 1;num++)
	{
		for (int i = 1;i <= n;i++)
		{
			for (int j = 1;j <= n;j++)
			{
				if (map[i][j] < INF)
				{
					if (dist[j] > dist[i] + map[i][j])
					{
						dist[j] = dist[i] + map[i][j];
					}
				}
			}
		}
	}
	for (int i = 1;i <= n;i++)
		printf("%d ", dist[i]);
	return 0;
}

如果您觉得这篇文章对您有所帮助，欢迎关注我的微信公众号–【悬浮流星】，阅读更多的类似文章。如果您发现该文章有错误或不足之处，也欢迎批评指正