单源最短路径算法：迪杰斯特拉 (Dijkstra) 算法（二）

一、基于邻接表的Dijkstra算法

　　如前一篇文章所述，在 Dijkstra 的算法中，维护了两组，一组包含已经包含在最短路径树中的顶点列表，另一组包含尚未包含的顶点。使用邻接表表示，可以使用 BFS 在O（V + E）时间中遍历图的所有顶点  。这个想法是使用 BFS 遍历图的所有顶点，并使用最小堆存储尚未包括在最短路径树中的顶点（或尚未确定最短距离的顶点）。最小堆用作优先级队列，以从尚未包括的顶点集中获取最小距离顶点。对于Min Heap，诸如 extract-min 和 reduce-key 值之类的操作的时间复杂度为 O（logV）。使用邻接表表示的 Dijkstra算法时间复杂度为 O（ELogV）。

二、详细步骤

　　1） 创建大小为 V 的最小堆，其中 V 是给定图中的顶点数。最小堆的每个节点都包含顶点数和顶点的距离值。
　　2） 以源顶点为根初始化 Min Heap（分配给源顶点的距离值为 0）。分配给所有其他顶点的距离值为 INF（无穷大）。
　　3） 当“最小堆”不为空时，执行以下操作：

• • 从“最小堆”中提取具有最小距离值节点的顶点。让提取的顶点为u。

• • 对于u的每个相邻顶点v，检查v是否在Min Heap中。如果 v 在“最小堆”中，并且距离值大于uv 的权重加上 u 的距离值，则更新 v 的距离值。

　　用下面的例子来理解。让给定的源顶点为 0：

 　　最初，源顶点到达自身的距离值为 0，对于所有其他顶点，INF 为无穷大。因此，从“最小堆”中提取源顶点，并更新与 0（1和7）相邻的顶点的距离值。“最小堆”包含除顶点 0 以外的所有顶点。绿色的顶点是确定了最小距离的顶点，并且不在“最小堆”中。

 　　由于顶点1 的距离值在最小堆中的所有节点中最小，因此从最小堆中提取顶点，并更新与 1 相邻的顶点的距离值（如果顶点不在最小堆中且距离 1 的距离较短，则更新距离比之前的距离）。最小堆包含除顶点0 和 1 以外的所有顶点。

 　　从最小堆中选取最小距离值的顶点。选择了顶点7。因此，最小堆现在包含除 0、1 和 7 以外的所有顶点。更新相邻 顶点7 的距离值。顶点6 和 8 的距离值变得有限（分别为15和9）。

 　　选择与最小堆的距离最小的顶点。选择了顶点6。因此，最小堆现在包含除 0、1、7 和 6 以外的所有顶点。更新相邻顶点6的距离值。更新顶点5 和 8 的距离值。

　　重复上述步骤，直到最小堆为空为止。最后，我们得到以下最短路径树。

三、代码

　　下面是使用了邻接矩阵的迪杰斯特拉算法实现。

    /**
     * 使用邻接表来实现Dijkstra的单源最短路径算法的函数
     *
     * @param adj 邻接表
     * @param src 源顶点
     */
    public void dijkstra(List<List<Node>> adj, int src) {
        this.adj = adj;
        for (int i = 0; i < V; i++) {
            dist[i] = Integer.MAX_VALUE;
        }

        /* 将源节点添加到优先级队列 */
        pq.add(new Node(src, 0));

        /* 源顶点与其自身的距离始终为0 */
        dist[src] = 0;

        while (settled.size() != V) {
            int u = pq.remove().node;
            settled.add(u);
            e_Neighbours(u);
        }
    }

　　处理传递的节点的所有邻居。

    /**
     * 处理传递过来的节点的所有邻居
     *
     * @param u
     */
    private void e_Neighbours(int u) {
        int edgeDistance = -1;
        int newDistance = -1;

        /* v的所有邻居 */
        for (int i = 0; i < adj.get(u).size(); i++) {
            Node v = adj.get(u).get(i);

            /* 如果当前节点尚未处理 */
            if (!settled.contains(v.node)) {
                edgeDistance = v.cost;
                newDistance = dist[u] + edgeDistance;

                /* 如果新距离的成本更低 */
                if (newDistance < dist[v.node])
                    dist[v.node] = newDistance;

                /* 将当前节点添加到队列 */
                pq.add(new Node(v.node, dist[v.node]));
            }
        }
    }

 源代码：

package algorithm.shortestpath;

import java.util.*;

public class DijkstraPQ {
    private int[] dist;             // 当前的距离数组
    private Set<Integer> settled;   // 存储最短路径处理完的顶点Set集合
    private PriorityQueue<Node> pq; // 优先级队列(min-heap)
    private int V;                  // 顶点数量
    List<List<Node>> adj;           // 邻接表

    public DijkstraPQ(int v) {
        this.V = v;
        dist = new int[V];
        settled = new HashSet<>();
        pq = new PriorityQueue<>(V, new Node());
    }

    /**
     * 使用邻接表来实现Dijkstra的单源最短路径算法的函数
     *
     * @param adj 邻接表
     * @param src 源顶点
     */
    public void dijkstra(List<List<Node>> adj, int src) {
        this.adj = adj;
        for (int i = 0; i < V; i++) {
            dist[i] = Integer.MAX_VALUE;
        }

        /* 将源节点添加到优先级队列 */
        pq.add(new Node(src, 0));

        /* 源顶点与其自身的距离始终为0 */
        dist[src] = 0;

        while (settled.size() != V) {
            int u = pq.remove().node;
            settled.add(u);
            e_Neighbours(u);
        }
    }

    /**
     * 处理传递的节点的所有邻居的函数
     *
     * @param u
     */
    private void e_Neighbours(int u) {
        int edgeDistance = -1;
        int newDistance = -1;

        /* v的所有邻居 */
        for (int i = 0; i < adj.get(u).size(); i++) {
            Node v = adj.get(u).get(i);

            /* 如果当前节点尚未处理 */
            if (!settled.contains(v.node)) {
                edgeDistance = v.cost;
                newDistance = dist[u] + edgeDistance;

                /* 如果新距离的成本更低 */
                if (newDistance < dist[v.node])
                    dist[v.node] = newDistance;

                /* 更新后将当前节点添加到最小堆中 */
                pq.add(new Node(v.node, dist[v.node]));
            }
        }
    }

    /**
     * 测试主函数
     *
     * @param args
     */
    public static void main(String[] args) {
        int V = 5;
        int source = 0;
        List<List<Node>> adj = new ArrayList<>();

        for (int i = 0;i < V; i++) {
            List<Node> item = new ArrayList<>();
            adj.add(item);
        }

        // 邻接表的输入
        adj.get(0).add(new Node(1, 9));
        adj.get(0).add(new Node(2, 6));
        adj.get(0).add(new Node(3, 5));
        adj.get(0).add(new Node(4, 3));

        adj.get(2).add(new Node(1, 2));
        adj.get(2).add(new Node(3, 4));

        DijkstraPQ dijkstraPQ = new DijkstraPQ(V);
        dijkstraPQ.dijkstra(adj, source);

        System.out.println("The shortest path form node: ");
        for (int i = 0; i < dijkstraPQ.dist.length; i++) {
            System.out.println(source + " to " + i + " is " + dijkstraPQ.dist[i]);
        }
    }
}

class Node implements Comparator<Node> {

    public int node;    // 顶点数
    public int cost;    // 顶点的距离值

    public Node() {
    }

    public Node(int node, int cost) {
        this.node = node;
        this.cost = cost;
    }

    @Override
    public int compare(Node o1, Node o2) {
        if (o1.cost < o2.cost)
            return -1;
        if (o1.cost > o2.cost)
            return 1;
        return 0;
    }
}