数据结构与算法--最短路径之Bellman算法、SPFA算法

除了Floyd算法,另外一个使用广泛且可以处理负权边的是Bellman-Ford算法。

Bellman-Ford算法

假设某个图有V个顶点E条边。

该算法主要流程是:

  • 初始化。到起点s的距离distTo[s]设置为0,其余顶点的dist[]设置为正无穷;
  • 以任意次序放松图中的所有E条边,重复V轮;
  • V轮放松结束后,判断是否存在负权回路。如果存在,最短路径没有意义。

根据流程可以给出代码,如下

package Chap7;

import java.util.LinkedList;
import java.util.List;

public class BellmanFord {
    private boolean hasNegativeCycle;
    private double distTo[];
    private DiEdge[] edgeTo;

    public boolean hasNegativeCycle() {
        return hasNegativeCycle;
    }

    private void relax(EdgeWeightedDiGraph<?> graph, int v) {
        for (DiEdge edge : graph.adj(v)) {
            int w = edge.to();
            if (distTo[v] + edge.weight() < distTo[w]) {
                distTo[w] = distTo[v] + edge.weight();
                edgeTo[w] = edge;
            }
        }
    }

    public BellmanFord(EdgeWeightedDiGraph<?> graph, int s) {
        distTo = new double[graph.vertexNum()];
        edgeTo = new DiEdge[graph.vertexNum()];
        for (int i = 0; i < graph.vertexNum(); i++) {
            distTo[i] = Double.POSITIVE_INFINITY; // 1.0 / 0.0为INFINITY
        }

        distTo[s] = 0.0;
        // 以上都是初始化

        for (int pass = 0; pass < graph.vertexNum(); pass++) {
            for (int v = 0; v < graph.vertexNum(); v++) {
                relax(graph, v);
            }
        }

        // 上面即使有负权回路也不会陷入死循环,因为给定了循环范围,算法必然终止。
        // 进行V轮边的松弛后,如果没有负权回路,那么所有的distTo[v] + edge.weight() >= distTo[w]
        // 如果对于图中任意边,仍然存在distTo[v] + edge.weight() < distTo[w],则存在负权回路
        for (int v = 0; v < graph.vertexNum(); v++) {
            for (DiEdge edge : graph.adj(v)) {
                int w = edge.to();
                if (distTo[v] + edge.weight() < distTo[w]) {
                    hasNegativeCycle = true;
                }
            }
        }
    }

    public double distTo(int v) {
        return distTo[v];
    }

    public boolean hasPathTo(int v) {
        return distTo[v] != Double.POSITIVE_INFINITY;
    }

    public Iterable<DiEdge> pathTo(int v) {
        if (hasPathTo(v)) {
            LinkedList<DiEdge> path = new LinkedList<>();
            for (DiEdge edge = edgeTo[v]; edge != null; edge = edgeTo[edge.from()]) {
                path.push(edge);
            }
            return path;
        }
        return null;
    }

    public static void main(String[] args) {
        List<String> vertexInfo = List.of("v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7");
        int[][] edges = {{4, 5}, {5, 4}, {4, 7}, {5, 7}, {7, 5}, {5, 1}, {0, 4}, {0, 2},
                {7, 3}, {1, 3}, {2, 7}, {6, 2}, {3, 6}, {6, 0}, {6, 4}};

        double[] weight = {0.35, 0.35, 0.37, 0.28, 0.28, 0.32, 0.38, 0.26, 0.39, 0.29,
                0.34, 0.40, 0.52, 0.58, 0.93};
        EdgeWeightedDiGraph<String> graph = new EdgeWeightedDiGraph<>(vertexInfo, edges, weight);
        BellmanFord[] all = new BellmanFord[graph.vertexNum()];

        for (int i = 0; i < all.length; i++) {
            all[i] = new BellmanFord(graph, i);
        }

        for (int s = 0; s < all.length; s++) {
            for (int i = 0; i < graph.vertexNum(); i++) {
                System.out.print(s + " to " + i + ": ");
                System.out.print("(" + all[s].distTo(i) + ") ");
                System.out.println(all[s].pathTo(i));
            }
            System.out.println();
        }
    }
}

在V轮放松完成后,如果没有负权回路存在,那么对于任何v -> w必然有distTo[v] + edge.weight() >= distTo[w],说明所有dist[w]已经是最短路径了;如果V轮后还存在distTo[v] + edge.weight() < distTo[w],说明distTo[w]无法收敛到最小值——陷入死循环了,我们围着那个环绕圈子,可以使得路径越来越短!这就是遇到了负权回路。

上面的例子没有负权回路存在,我们特意制造一个,看看结果。

public static void main(String[] args) {
    List<String> vertexInfo = List.of("v0", "v1", "v2", "v3");
    int[][] edges = {{0, 1}, {1, 2}, {2, 0}, {0, 3}, {2, 3}};

    double[] weight = {-9 , 5, 2, 4, 6};
    EdgeWeightedDiGraph<String> graph = new EdgeWeightedDiGraph<>(vertexInfo, edges, weight);
    BellmanFord bellmanFord = new BellmanFord(graph, 0);
    if (bellmanFord.hasNegativeCycle()) {
        System.out.println("路径中存在负权环!");
    }
}

0 -> 1-> 2 -> 0是一个负权回路。这里也注意下,如果图中有边的权值为负,在求最短的路径的时候要先判断有没有负权回路存在再进行后续计算。

SPFA算法--Bellman-Ford算法的优化

其实,根据经验我们很容易知道在任意一轮中许多边都不会放松成功。我们下次需要放松的顶点,只需是上次dist[w]值发生改变的那些w顶点。为此用一个队列保存这些顶点,用一个onPQ[]的布尔数组,来判断某个顶点是否已经在队列中。基于队列优化的Bellm-Ford算法又称为SPFA算法(Shortest Path Faster Algorithm)。

SPFA算法的思路是:每次放松一条边v -> w,如果放松成功(即distTo[w]的值被更新),且w没有在队列中则将其入列。然后队列的顶点出列并放松它,直到队列为空或者找到负权回路,算法终止。

这些数据结构可以保证:

  • 队列中不会出现重复的顶点;
  • 在某一轮中,改变了dist[w]和edge[w]的所有w将会在下一轮处理。

如果不存在从起点s可达的负权回路,那么算法终止的条件将是队列为空;如果存在呢?队列永远不会空(又在兜圈子了)!这意味着程序永不会结束,为此,我们必须判断从s可达的路径中是否存在负权回路。如果存在,应该立即停止算法,因为负权回路使得最短路径的研究毫无意义。而且此时经V轮放松后的edgeTo[]中必然会形成一个环,且权值和为负数。但很可能在全部V轮结束前就可以从edgeTo[]中找到负权回路,所以在放松边的过程中,可以隔若干轮就检查一下edgeTo[]中的路径是否成负权回路。

由于不是V轮结束后才检查是否存在负权回路,而是一边放松,一边检查,所以像上面那样用distTo[v] + edge.weight() < distTo[w]的方法来判断已经不适用了,因为放松尚未完成,上式成立很正常(说明需要更新最短路径了)。于是我们采用一种更通用的方法:先判断是否存在有向环,再判断该环的权值和是不是负数。

寻找有向负权环

判断有向环的实现并不复杂,核心思想其实是DFS(深度优先搜索)。

package Chap7;

import java.util.LinkedList;

public class NegativeDiCycle {
    private boolean[] marked;
    private DiEdge[] edgeTo;
    private boolean[] onStack;
    private LinkedList<DiEdge> cycle;

    public NegativeDiCycle(EdgeWeightedDiGraph<?> graph) {
        marked = new boolean[graph.vertexNum()];
        edgeTo = new DiEdge[graph.vertexNum()];
        onStack = new boolean[graph.vertexNum()];
        // 有向图可能不是强连通的,所以需要从每个顶点出发,寻找负权环
        for (int i = 0; i < graph.vertexNum(); i++) {
            dfs(graph, i);
        }
    }

    private void dfs(EdgeWeightedDiGraph<?> graph, int v) {
        // 模拟系统递归使用的栈,方法开始进栈;方法结束出栈
        onStack[v] = true;
        marked[v] = true;
        for (DiEdge edge : graph.adj(v)) {
            // 如果已经存在负权回路,终止递归方法
            if (this.hasNegativeDiCycle()) {
                return;
            }

            int w = edge.to();
            if (!marked[w]) {
                edgeTo[w] = edge;
                dfs(graph, w);
                // v -> w的路径,且w在栈中,说明形成有向环
            } else if (onStack[w]) {
                cycle = new LinkedList<>();

                DiEdge e = edgeTo[v];
                while (e.from() != w) {
                    cycle.push(e);
                    e = edgeTo[e.from()];
                }
                // 为避免空指针,离w最近的那条在循环外入栈
                cycle.push(e);
                // 把导致成环的边加入
                cycle.push(edge);
            }
        }
        onStack[v] = false;
    }

    public boolean hasNegativeDiCycle() {
        if (cycle != null) {
            double cycleWeight = cycle.stream().mapToDouble(DiEdge::weight).sum();
            if (cycleWeight < 0) {
                return true;
            }
        }
        return false;
    }

    public Iterable<DiEdge> cycle() {
        if (hasNegativeDiCycle()) {
            return cycle;
        }
        return null;
    }

}

使用DFS的原因主要是为了利用递归产生的由系统维护的栈(每次方法调用就相当于入栈,最先调用的最后才返回),而递归方法dfs的调用顺序正好反映了顶点的访问顺序,如先调用dfs(s), 接着dfs(w), 然后dfs(x),再递归调用dfs(v),那么这是一条s -> w -> x -> v的路径。我们使用了一个onStack[]布尔数组来模拟方法调用的进出栈情况——进入方法体说明方法被调用,进栈;方法执行完毕,该返回到上一层方法调用中了,出栈。onStack[]其实就是一条路径,onStack[v] = true说明顶点v位于从起点s可达的onStack[]这条路径中。

该实现最为关键的就是理解:当我们在v处发现某条v -> w的边,而恰好其w位于onStack[]中,就找到了一个环。我们知道onStack[]表示的是s -> w -> x -> v的路径,现在v -> w 刚好补全w -> x -> v成为环!如下图所示

好,寻找到有向环后,再判断环内所有边的权值是不是负数就好了。该实现不仅能判断,还能找出到底是哪些边造成了环。关键是以下几行

DiEdge e = edgeTo[v];
while (e.from() != w) {
    cycle.push(e);
    e = edgeTo[e.from()];
}
// 为避免空指针,离w最近的那条在循环外入栈
cycle.push(e);
// 把导致成环的边加入
cycle.push(edge);

对照着上图,最先x -> v入栈,到w -> x时候,发现e.from()就是w,不存入。出了while循环,将这条w -> x入栈,最后别忘了把导致成环的那条边入栈。有人可能会说了为何要这么麻烦,循环外单独push了两次,这是因为edgeTo[]中有的值是null(比如起点s),如果不在合适的地方终止循环,将在e = edgeTo[e.from()]该语句执行后,在e.from() != w处引起空指针异常!

SPFA算法的实现

可以判断负权回路的是否存在了,据此实现SPFA算法。

package Chap7;

import java.util.*;

public class SPFA {
    private double[] distTo;
    private DiEdge[] edgeTo;
    private Queue<Integer> queue;
    private boolean[] onPQ;  // 顶点是否在queue中
    private int cost; // 记录放松了边的次数
    private Iterable<DiEdge> cycle; // 找到的负权回路

    public boolean hasNegativeCycle() {
        return cycle != null;
    }

    private void findNegativeCycle() {

        EdgeWeightedDiGraph<String> g = new EdgeWeightedDiGraph<>(edgeTo.length);
        for (int v = 0; v < edgeTo.length; v++) {
            if (edgeTo[v] != null) {
                g.addDiEdge(edgeTo[v]);
            }
        }
        NegativeDiCycle cycleFinder = new NegativeDiCycle(g);
        if (cycleFinder.hasNegativeDiCycle()) {
            cycle = cycleFinder.cycle();
        }
    }

    private void relax(EdgeWeightedDiGraph<?> graph, int v) {
        for (DiEdge edge : graph.adj(v)) {
            int w = edge.to();
            if (distTo[v] + edge.weight() < distTo[w]) {
                distTo[w] = distTo[v] + edge.weight();
                edgeTo[w] = edge;
                if (!onPQ[w]) {
                    queue.offer(w);
                    onPQ[w] = true;
                }
            }
            // 每调放松一条边cost自增;每放松了graph.vertexNum条边,就检查是否有负权回路
            if (cost++ % graph.vertexNum() == 0) {
                findNegativeCycle();
            }
        }
    }

    public SPFA(EdgeWeightedDiGraph<?> graph, int s) {
        distTo = new double[graph.vertexNum()];
        edgeTo = new DiEdge[graph.vertexNum()];
        queue = new LinkedList<>();
        onPQ = new boolean[graph.vertexNum()];

        for (int i = 0; i < graph.vertexNum(); i++) {
            distTo[i] = Double.POSITIVE_INFINITY; // 1.0 / 0.0为INFINITY
        }

        distTo[s] = 0.0;
        // 以上都是初始化
        queue.offer(s);
        onPQ[s] = true;

        while (!queue.isEmpty() && !hasNegativeCycle()) {
            int v = queue.poll();
            onPQ[v] = false;
            relax(graph, v);
        }
    }

    public Iterable<DiEdge> cycle() {
        return cycle;
    }

    public double distTo(int v) {
        return distTo[v];
    }

    public boolean hasPathTo(int v) {
        return distTo[v] != Double.POSITIVE_INFINITY;
    }

    public Iterable<DiEdge> pathTo(int v) {
        if (hasPathTo(v)) {
            LinkedList<DiEdge> path = new LinkedList<>();
            for (DiEdge edge = edgeTo[v]; edge != null; edge = edgeTo[edge.from()]) {
                path.push(edge);
            }
            return path;
        }
        return null;
    }

    public static void main(String[] args) {
        List<String> vertexInfo = List.of("v0", "v1", "v2", "v3");
        int[][] edges = {{0, 1}, {1, 2}, {2, 0}, {0, 3}, {2, 3}};

        double[] weight = {-9 , 5, 2, 4, 6};
        EdgeWeightedDiGraph<String> graph = new EdgeWeightedDiGraph<>(vertexInfo, edges, weight);

        SPFA spfa = new SPFA(graph, 0);
        if (spfa.hasNegativeCycle()) {
            System.out.print("存在负权环:");
            System.out.println(spfa.cycle());
        }
    }
}

程序将输出找到的负权回路,打印[(2->0 2.0), (0->1 -9.0), (1->2 5.0)]。对于不存在负权回路的图,SPFA当然也能正确处理。这里就不测试了。

代码中特别注意一点,我们之前有提到需要隔若干次就检查是否存在负权回路,所以用到一个int型的cost变量记录放松边的次数,每放松了V条边就检查一次。因为可能在第V次放松之后,edgeTo[]数组中就存在负权回路了。findNegativeCycle方法就是将edgeTo[]转化成了有向图送给NegativeDiCycle类,检测是否存在负权回路。


by @sunhaiyu

2017.9.26

数据结构与算法--最短路径之Bellman算法、SPFA算法的更多相关文章

  1. 算法提高 道路和航路 SPFA 算法

    我简单的描述一下题目,题目中所说的有道路和航路: 1.公路是双向的,航路是单向的: 2.公路是正值,航路可正可负: 每一条公路i或者航路i表示成连接城镇Ai(1<=A_i<=T)和Bi(1 ...

  2. SPFA算法——最短路径

    粗略讲讲SPFA算法的原理,SPFA算法是1994年西南交通大学段凡丁提出 是一种求单源最短路的算法 算法中需要用到的主要变量 int n;  //表示n个点,从1到n标号 int s,t;  //s ...

  3. 【算法】单元最短路径之Bellman-Ford算法和SPFA算法

    SPFA是经过对列优化的bellman-Ford算法,因此,在学习SPFA算法之前,先学习下bellman-Ford算法. bellman-Ford算法是一种通过松弛操作计算最短路的算法. 适用条件 ...

  4. [hihoCoder] #1093 : 最短路径·三:SPFA算法

    时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 万圣节的晚上,小Hi和小Ho在吃过晚饭之后,来到了一个巨大的鬼屋! 鬼屋中一共有N个地点,分别编号为1..N,这N个地点之 ...

  5. 图论——最短路:Floyd,Dijkstra,Bellman-Ford,SPFA算法及最小环问题

    一.Floyd算法 用于计算任意两个节点之间的最短路径. 参考了five20的博客 Floyd算法的基本思想如下:从任意节点A到任意节点B的最短路径不外乎2种可能,1是直接从A到B,2是从A经过若干个 ...

  6. (转)SPFA算法

    原文地址:http://www.cnblogs.com/scau20110726/archive/2012/11/18/2776124.html 粗略讲讲SPFA算法的原理,SPFA算法是1994年西 ...

  7. SPFA 算法(剪辑)(学习!)

    SPFA算法 单源最短路径的算法最常用的是Dijkstra,些算法从时间复杂度来说为O(n^2),但是面对含有负权植的图来说就无能为力了,此时 Dellman-ford算法就有用了,这咱算法是采用的是 ...

  8. 转载:SPFA算法学习

    转载地址:http://www.cnblogs.com/scau20110726/archive/2012/11/18/2776124.html 粗略讲讲SPFA算法的原理,SPFA算法是1994年西 ...

  9. 最短路径算法 4.SPFA算法(1)

    今天所说的就是常用的解决最短路径问题最后一个算法,这个算法同样是求连通图中单源点到其他结点的最短路径,功能和Bellman-Ford算法大致相同,可以求有负权的边的图,但不能出现负回路.但是SPFA算 ...

随机推荐

  1. 使用System.Net.Mail中的SMTP发送邮件(带附件)

    System.Net.Mail 使用简单邮件传输协议SMTP异步发送邮件 想要实现SMTP发送邮件,你需要了解这些类 SmtpClient :使用配置文件设置来初始化 SmtpClient类的新实例. ...

  2. NET 获取实例所表示的日期是星期几

    获取日期枚举,可以根据switch去进行操作 DateTime.Now.DayOfWeek

  3. .net core Area独立成单独的dll文件

    以前做MES项目遇到过这个情况,一个项目有7到8个大模块,生产.质量.物耗.电子看板.设备等,每个模块都有大量业务,这样使用mvc结构如果所有模块放在一个目录中,那么势必会产生很多问题,各模块代码不好 ...

  4. unity2D 船只型物体驱动的实现

    船只向前行驶的驱动力 假设在水中没有摩擦阻力,船只有惯性,船只可以转弯,按下前进键时船只会在力的作用下使得自身的物理运动方向变化到自身的前方方向,从而向前行进. 上图中 V:船当前物理速度 V1,V2 ...

  5. [面试题目]IT面试中的一些基础问题

    1. 面向对象的特征 继承,封装,多态 2. 重写和重载的区别 重写:在继承当中,子类重写父类的函数,函数声明完全一样,只是函数里面的操作不一样,这样叫做重写. 重载:与多态无关,即两个函数名一样的成 ...

  6. 【BZOJ5290】 [Hnoi2018]道路

    BZOJ5290 [Hnoi2018]道路 前言 这道题目我竟然没有在去年省选切? 我太菜了. Solution 对题面进行一个语文透彻解析,发现这是一个二叉树,乡村都是叶子节点,城市都有两个儿子.( ...

  7. PHP 获取两个时间之间的月份

    ## 获取两个时间之间的间距时间 $s = '2017-02-05'; $e = '2017-07-20'; $start = new \DateTime($s); $end = new \DateT ...

  8. IO、NIO、AIO

    一. IO 传统的IO是同步阻塞模式,数据的读取与写入会阻塞在一个线程内等待其完成. 主要面向字节流编程.(流是单向的) 二. NIO NIO支持同步非阻塞模式,在进行IO调用后,然后去 轮询调用结果 ...

  9. tomcat服务的启动与隐藏启动(win)

    一:  tomcat的启动与隐藏启动 1. 正常启动:D:\apache-tomcat-8.5.24\bin中的   startup.bat  双击启动 2. 启动tomcat服务后,window下方 ...

  10. 上传本地文件到github(码云)上(小乌龟方式,sourcetree方式)

    一:上传文件到 github 1.打开 https://github.com/ 登录github账号(没有的自己创建),点击右上角创建新仓库 在打开的页面中填写  名字 点击 Create repos ...