图论算法（三）--最短路径 的Bellman-Flod [ 带负权值图 ] 的解法（JAVA ）

Bellman-Flod算法

对于带有负权值的图，我们已经不能通过Dijkstra算法进行求解了
原因：Dijkstra每次都会找一个距源点（设为s）最近的点，然后将该距离定为这个点到源点的最短路径；如果一个顶点u被加入了book[i])( book[i] == 1 说明这个s到u的路径权值已被记录，不可再更改)，但是如果存在v到u的权值为负，那么s经v到u到值要更小。
例如：

如果用Dijkstra跑只能得到2这个结果，但实际结果应该是1才对
s—->u 2
s—->v—-> 1

---

为解决带负权值的问题，这里需要用到Bellman-Flod算法
问题描述：有如下带负权值的图，求从1号点到其他各点的最短路径长度

Input：
5 5
2 3 2
1 2 -3
1 5 5
4 5 2
3 4 3

Output:
0 -3 -1 2 4

import java.util.Scanner;
public class minPath {
    static int[] u = new int[10];
    static int[] v = new int[10];
    static int[] w = new int[10];
    static int[] dis = new int[10];
    static int n, m;
    static Scanner input  = new Scanner(System.in);

    public static void main(String[] args) {
        n = input.nextInt();
        m = input.nextInt();
        for (int i = 1; i <= m; i++) {
            u[i] = input.nextInt();
            v[i] = input.nextInt();
            w[i] = input.nextInt();
        }
        for (int i = 1; i <= n; i++) {
            dis[i] = 99999999;
        }
        dis[1] = 0;
        bellmanFlod();
        for (int i = 1; i <= n; i++) {
            System.out.print(dis[i] + " ");
        }
    }

    private static void bellmanFlod() {
        /**
         * 由离散数学的理论得出，在一个n个顶点的图中，任意两点之间的最短路径最多包含n-1条边
         * */
        for (int i = 1; i <= n - 1; i++) {
            for (int j = 1; j <= m; j++) {
                if (dis[v[j]] > dis[u[j]] + w[j]) {
                    dis[v[j]] = dis[u[j]] + w[j];
                }
            }
        }
    }
}

时间复杂度：O(NM)

算法优化

优化版本一

优化原因：在实际操作中，很多时候不会进行n-1次，毕竟不是每个点都会达到n-1条边的情况的，因此当不在能更新之后，我们就可以终止程序了，即使现在还没进行到第n-1阶段。

优化方法：添加一个一维数组备份来dis，如果新一轮的松弛中数组没有发生变化，则可以提前跳出循环。

import java.util.Scanner;

public class minPath {
    static int[] u = new int[10];
    static int[] v = new int[10];
    static int[] w = new int[10];
    static int[] dis = new int[10];
    static int[] bak = new int[10];
    static int n, m;
    static int check, flag;
    static Scanner input  = new Scanner(System.in);

    public static void main(String[] args) {
        n = input.nextInt();
        m = input.nextInt();
        for (int i = 1; i <= m; i++) {
            u[i] = input.nextInt();
            v[i] = input.nextInt();
            w[i] = input.nextInt();
        }
        for (int i = 1; i <= n; i++) {
            dis[i] = 99999999;
        }
        dis[1] = 0;

        bellmanFlod();

        if (flag == 1) {
            System.out.println("此图含有负权回路");
        } else {
            for (int j = 1; j <= n; j++) {
                System.out.print(dis[j] + " ");
            }
        }
    }

    private static void bellmanFlod() {
        /**
         * 由离散数学的理论得出，在一个n个顶点的图中，任意两点之间的最短路径最多包含n-1条边
         * */
        for (int i = 1; i <= n - 1; i++) {
            bak[i] = dis[i];
            for (int j = 1; j <= m; j++) {
                if (dis[v[j]] > dis[u[j]] + w[j]) {
                    dis[v[j]] = dis[u[j]] + w[j];
                }
            }
            /**
             * 检测dis是否还在变化
             * */
            check = 0;
            for (int j = 1; j <= n; j++) {
                if (bak[i] != dis[i]) {
                    check = 1;
                    break;
                }
                if (check == 0) {
                    break;
                }
            }
            /**
             * 检测负权回路
             * 原理：最短路径所包含的边做多为n-1条，在进行n-1次松弛之后如果还能继续松弛成功，
             * 那说明此图必定含有负权回路
             * */
            flag = 0;
            for (int j = 1; j <= m; j++) {
                if (dis[v[i]] > dis[u[i]] + w[i]) {
                    flag = 1;
                }
            }
        }
    }
}

优化原因：因为最短路径做多有n-1条边，所以Bellman-Ford算法做多有n-1个阶段。而每个阶段都要对每条边进行“松弛操作”，使得“估计值”变为“确定值”。而对于本阶段来说，上个阶段松弛完的结果是不会再改变的，而原算法每个阶段都会重新计算，浪费时间。

优化方法：每次仅对最短路“估计值”变化为“确定值”的顶点的所有出边执行松弛操作，可以采用队列进行优化
时间复杂度：O(NM)

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class minPath {
    static int[] u = new int[8];
    static int[] v = new int[8];
    static int[] w = new int[8];
    /**
     * first 要比 n 的值大1
     * next  要比 m 的值大1
     * */
    static int[] first = new int[6];
    static int[] next = new int[8];

    static int[] dis = new int[6];
    static int[] book = new int[6];
    static int n, m;
    static Queue<Integer> queue = new LinkedList<>();
    static Scanner input = new Scanner(System.in);

    public static void main(String[] args) {

        n = input.nextInt();
        m = input.nextInt();

        for (int i = 1; i <= n; i++) {
            dis[i] = 99999999;
        }
        dis[1] = 0;
        for (int i = 1; i <= n; i++) {
            first[i] = -1;
        }

        for (int i = 1; i <= m; i++) {
            u[i] = input.nextInt();
            v[i] = input.nextInt();
            w[i] = input.nextInt();
            /**
             * 建立邻接表的关键语句！！！
             * */
            next[i] = first[u[i]];
            first[u[i]] = i;
        }

        queue.offer(1);
        book[1] = 1;

        bellomanFlodPlus();

        for (int i = 1; i <= n; i++) {
            System.out.print(dis[i] + " ");
        }
    }

    private static void bellomanFlodPlus() {
        while (!queue.isEmpty()) {
            /**
             * 当前的队首元素
             * */
            int k = first[queue.peek()];
            while (k != -1) {

                if (dis[v[k]] > dis[u[k]] + w[k]) {
                    dis[v[k]] = dis[u[k]] + w[k];
                    /**
                     * 用数组来判断v[k]是否已经在队列中
                     * 不使用数组进行记录的话，要迭代队列，十分不方便
                     * */
                    if(book[v[k]] == 0) {
                        queue.offer(v[k]);
                        book[v[k]] = 1;
                    }
                }
                k = next[k];
            }
            book[queue.peek()] = 0;
            queue.remove();
        }
    }
}