SPFA

一、解決問題

從圖中的某個頂點出發到達另一個頂點的最短路徑。

 

二、算法思路

Shortest Path Faster Algorithm (SPFA)。一般認為是隊列優化的貝爾曼-福特算法。是一個用於求有向帶權圖單源最短路徑的算法，並且適用於有負權重的圖。如果一個頂點被加入了超過頂點的個數，則這個圖就有負環

基本思路

• 每個節點都用於松弛其相鄰節點的備選節點。
• 維護一個備選節點隊列
• 僅有節點被松弛后才會放入隊列
• 上述流程不斷重復直到隊列沒有節點

 

偽代碼：

function spfa(G, s):
    //初始化所有節點都是最大距離
    for each vertex != s in G:
        d[vertex] = inf
    d[s] = 0
    offer s into queue
    while(queue is not empty):
        u = poll queue
        for each v in edge(u):
            if d[u] + w[u, v] < d[v]:
                d[v] = d[u] + w[u,v]
                if v not in queue:
                    offer v into queue

 

 

三、圖例

首先算一下最短路徑為了用來驗證

distance(1,5) = 8
distance(1,4) = 3
distance(1,2) = 9
distance(1,3) = 11
distance(1,6) = 12

 

過程

• d[a] 為源點到a的距離
• poll為從隊列取出點
• offer為每次放入隊列的點
• q為隊列
• 紅色的為最后的結果

 

四、 Code (這里面的圖表示形式用鏈式前向星更簡潔一些)

package algorithm;


import java.util.*;

public class SPFATest {
    private static final int INF = 0x7fffffff;
    private static class Edge {
        int source;
        int target;
        int weight;

        private Edge(int source, int target, int weight){
            this.source = source;
            this.target = target;
            this.weight = weight;
        }
    }
    public static class Graph {
        

        int[] nodes;
        HashMap<Integer, List<Edge>> nodeWithEdges;

        private Graph init(int[] nodes, List<Edge> edges) {
            this.nodes = nodes;
            nodeWithEdges = new HashMap<>();
            for (Edge edge : edges) {
                List<Edge> edgeTemp = nodeWithEdges.getOrDefault(edge.source, new ArrayList<>());
                edgeTemp.add(edge);
                nodeWithEdges.put(edge.source, edgeTemp);
            }
            return this;
        }

        public int[] getAllNodes() {
            return this.nodes;
        }

        private List<Edge> getEdgesOfNode(int node) {
            return nodeWithEdges.get(node);
        }
    }

    public static int[] SPFA(int source, Graph graph) {
        int n = graph.nodes.length;
        int[] d = new int[n+1];
        for (int i = 0; i <= n; i++) {
            d[i] = INF;
        }
        d[source] = 0;
        boolean[] nodeExistsInQ = new boolean[n+1];
        Deque<Integer> deque = new ArrayDeque<>();
        deque.offer(source);
        nodeExistsInQ[source] = true;

        while (!deque.isEmpty()) {
            int u = deque.poll();
            nodeExistsInQ[u] = false;
            if(graph.getEdgesOfNode(u) == null) continue;

            for (Edge edge : graph.getEdgesOfNode(u)) {
                int v = edge.target;
                if (d[u] + edge.weight < d[v]) {
                    d[v] = edge.weight + d[u];

                    if(!nodeExistsInQ[v]){
                        deque.offer(v);
                        nodeExistsInQ[u] = true;
                    }
                }
            }
        }
        return d;
    }

    public static void main(String [] args){
        int []nodes = new int[]{1,2,3,4,5,6};
        List<Edge> edges = new ArrayList<>();
        edges.add(new Edge(1,2,9));
        edges.add(new Edge(1,4,3));
        edges.add(new Edge(1,5,13));
        edges.add(new Edge(2,4,7));
        edges.add(new Edge(2,3,2));
        edges.add(new Edge(3,4,20));
        edges.add(new Edge(3,6,1));
        edges.add(new Edge(4,5,5));
        edges.add(new Edge(4,6,19));

        Graph graph = new Graph().init(nodes, edges);

        int []d = SPFA(1, graph);
        for(int i = 1; i <= nodes.length; i++){
            System.out.println(d[i]);
        }
    }
}