最短路径算法

在日常生活中，我们如果需要常常往返A地区和B地区之间，我们最希望知道的可能是从A地区到B地区间的众多路径中，那一条路径的路途最短。最短路径问题是图论研究中的一个经典算法问题， 旨在寻找图（由结点和路径组成的）中两结点之间的最短路径。
算法具体的形式包括：
（１）确定起点的最短路径问题：即已知起始结点，求最短路径的问题。
（２）确定终点的最短路径问题：与确定起点的问题相反，该问题是已知终结结点，求最短路径的问题。在无向图中该问题与确定起点的问题完全等同，在有向图中该问题等同于把所有路径方向反转的确定起点的问题。
（３）确定起点终点的最短路径问题：即已知起点和终点，求两结点之间的最短路径。
（４）全局最短路径问题：求图中所有的最短路径。
用于解决最短路径问题的算法被称做“最短路径算法”， 有时被简称作“路径算法”。
最常用的路径算法有：Dijkstra算法、A*算法、Bellman-Ford算法、Floyd-Warshall算法、Johnson算法。
本文主要研究Dijkstra算法的单源算法。

Dijkstra算法思想
Dijkstra算法思想为：设G=(V,E)是一个带权有向图，把图中顶点集合V分成两组，第一组为已求出最短路径的顶点集合（用S表示，初始时S中只有一个源点，以后每求得一条最短路径 , 就将 加入到集合S中，直到全部顶点都加入到S中，算法就结束了），第二组为其余未确定最短路径的顶点集合（用U表示），按最短路径长度的递增次序依次把第二组的顶点加入S中。在加入的过程中，总保持从源点v到S中各顶点的最短路径长度不大于从源点v到U中任何顶点的最短路径长度。此外，每个顶点对应一个距离，S中的顶点的距离就是从v到此顶点的最短路径长度，U中的顶点的距离，是从v到此顶点只包括S中的顶点为中间顶点的当前最短路径长度。
以下图为例：

package com.gloomy.graph;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 解决单源最短路径问题的一般方法-Dijikstra算法 假设无负值圈
 * 
 * @author 过路的守望
 *
 */
public class DijkstraAlgorithm {

    private static class Vertex {

        /*
         * @label 标签
         */
        private String label;
        /*
         * @dist 起始顶点到此顶点的距离
         */
        private int dist = Integer.MAX_VALUE;

        /*
         * 邻接表
         */
        private List<Vertex> adjacentList;

        /*
         * 当前顶点的前继顶点
         */
        private Vertex preVertex;

        /*
         * 记录是否处理完
         */
        private boolean visited;
        /*
         * 用一个HashMap记录当前顶点与邻接顶点之间边的距离
         */
        private Map<Vertex, Integer> adjacentEdgesMap;

        public Vertex(String label) {
            adjacentList = new ArrayList<DijkstraAlgorithm.Vertex>();
            adjacentEdgesMap = new HashMap<DijkstraAlgorithm.Vertex, Integer>();
            this.label = label;

        }

        public Map<Vertex, Integer> getAdjacentEdgesMap() {
            return adjacentEdgesMap;
        }

        public List<Vertex> getAdjacentList() {
            return adjacentList;
        }

        public int getDist() {
            return dist;
        }

        public String getLabel() {
            return label;
        }

        public Vertex getPreVertex() {
            return preVertex;
        }

        public boolean isVisited() {
            return visited;
        }

        public void setAdjacentEdgesMap(Map<Vertex, Integer> adjacentEdgesMap) {
            this.adjacentEdgesMap = adjacentEdgesMap;
        }

        public void setAdjacentList(List<Vertex> adjacentList) {
            this.adjacentList = adjacentList;
        }

        public void setDist(int dist) {
            this.dist = dist;
        }

        public void setLabel(String label) {
            this.label = label;
        }

        public void setPreVertex(Vertex preVertex) {
            this.preVertex = preVertex;
        }

        public void setVisited(boolean visited) {
            this.visited = visited;
        }

    }

    public static void main(String[] args) {
        DijkstraAlgorithm dijkstraAlgorithm = new DijkstraAlgorithm();
        Vertex A = new Vertex("A");
        Vertex B = new Vertex("B");
        Vertex C = new Vertex("C");
        Vertex D = new Vertex("D");
        Vertex E = new Vertex("E");
        Vertex F = new Vertex("F");
        Vertex G = new Vertex("G");
        A.getAdjacentList().add(B);
        A.getAdjacentList().add(D);
        A.getAdjacentEdgesMap().put(B, 2);
        A.getAdjacentEdgesMap().put(D, 1);
        B.getAdjacentList().add(D);
        B.getAdjacentEdgesMap().put(D, 3);
        B.getAdjacentList().add(E);
        B.getAdjacentEdgesMap().put(E, 10);
        C.getAdjacentList().add(A);
        C.getAdjacentEdgesMap().put(A, 4);
        C.getAdjacentList().add(F);
        C.getAdjacentEdgesMap().put(F, 5);
        D.getAdjacentList().add(C);
        D.getAdjacentEdgesMap().put(C, 2);
        D.getAdjacentList().add(F);
        D.getAdjacentEdgesMap().put(F, 8);
        D.getAdjacentList().add(G);
        D.getAdjacentEdgesMap().put(G, 4);
        D.getAdjacentList().add(E);
        D.getAdjacentEdgesMap().put(E, 2);
        E.getAdjacentList().add(G);
        E.getAdjacentEdgesMap().put(G, 6);
        G.getAdjacentList().add(F);
        G.getAdjacentEdgesMap().put(F, 1);
        List<Vertex> vertexs = new ArrayList<DijkstraAlgorithm.Vertex>();
        vertexs.add(A);
        vertexs.add(B);
        vertexs.add(C);
        vertexs.add(D);
        vertexs.add(E);
        vertexs.add(F);
        vertexs.add(G);
        dijkstraAlgorithm.dijkstraAlgorithm(A, vertexs);

    }

    public void dijkstraAlgorithm(Vertex vertex, List<Vertex> vertexs) {
        /*
         * 将起始顶点的路径长设为0。s->s的路径长为0。
         */
        vertex.setDist(0);
        /*
         * 标记已经访问过
         */

        while (true) {
            /*
             * 已访问全部顶点返回
             */
            if (null == vertex) {
                break;
            }
            vertex.setVisited(true);
            updateDist(vertex);
            /*
             * 从未访问的顶点里寻找路径长最短的顶点
             */
            vertex = findMinDistUnknownVertex(vertexs);
        }
        /*
         * 打印起始顶点所有节点的最短路径
         */
        for (Vertex vertex2 : vertexs) {
            printPath(vertex2);
            System.out.println();
        }

    }

    /**
     * 从未访问顶点中寻找路径长最短的顶点 可用配对堆优化查找路径长最短的顶点
     * @param vertex
     * @return
     */
    private Vertex findMinDistUnknownVertex(List<Vertex> vertexs) {
        int min = Integer.MAX_VALUE;
        Vertex minVertex = null;
        for (Vertex vertex : vertexs) {
            if (!vertex.isVisited()) {
                if (vertex.getDist() < min) {
                    min = vertex.getDist();
                    minVertex = vertex;
                }
            }
        }
        return minVertex;
    }

    /**
     * 打印当前顶点到起始顶点的最短路径
     * @param vertex
     */
    private void printPath(Vertex vertex) {
        if (vertex.preVertex != null) {
            printPath(vertex.getPreVertex());
            System.out.print(" "+"to"+" ");
        }
        System.out.print(vertex.getLabel());

    }

    /*
     * 更新顶点vertex的邻接顶点的路径长
     */
    public void updateDist(Vertex vertex) {
        for (Vertex adjacentVertex : vertex.getAdjacentList()) {
            /*
             * 由于已假设无负值圈，每次选取的顶点是已知路径长最短的顶点，故其路径长不可能变得更短。从始至终其路径长度只会更新一次。
             */
            if (!adjacentVertex.isVisited()) {
                /*
                 * 更新路径长度
                 */
                if (adjacentVertex.getDist() > vertex.getDist()
                        + vertex.getAdjacentEdgesMap().get(adjacentVertex)) {
                    adjacentVertex.setDist(vertex.getDist()
                            + vertex.getAdjacentEdgesMap().get(adjacentVertex));
                    /*
                     * 记录前继顶点
                     */
                    adjacentVertex.setPreVertex(vertex);
                }
            }
        }
    }
}

输出结果：
A
A to B
A to D to C
A to D
A to D to E
A to D to G to F
A to D to G