一、問題介紹

1.求K條最短路徑的必要性

最短路徑問題分為：

單源最短路徑
所有頂點對間的最短路徑

共同的缺陷：
這里的最短路徑指兩點間最短的那一條路徑，不包括次短、再次短等路徑。這樣的最短路徑問題比較狹義。
在實際情況中，例如：用戶在使用咨詢系統或決策支持系統時，希望得到最優的決策參考外，還希望得到次優、再次優等決策參考，這同樣反映在最短路徑問題上。因此有必要將最短路徑問題予以擴展和延伸，稱為K條最短路徑問題，即不但要求得最短路徑，還要求得次短、再次短等路徑。

2.KSP問題定義

KSP問題是對最短路徑問題的推廣，它除了要確定最短路徑之外，還要確定次短路徑、第三短路徑，...，知道找到第K短路徑。用Pi表示從起點s到終點t的第i短路徑，KSP問題是確定路徑集合Pk={p1,p2,p3,...,pk}，使得滿足以下3個條件：
1）K條路徑是按次序產生的，即對于所有的i（i=1,2,...,K-1），pi是在pi+1之前確定；
2）K條路徑是按長度從小到大排列的，即對于所有的i（i=1,2,...,K-1），都有c(pi)<c(pi+1)；
3）這K條路徑是最短的，即對于所有的p∈Pst-PK，都有c(pk)<c(p)。

3.相關概念

用于說明偏離概念的圖

設起點為 1 ，終點為 5 。p1、p2、p3 分別表示起點到終點間最短路徑、第二短路徑、第三短路徑。

1）偏離點

p3相對于p1的偏離節點為節點 2

2）偏離邊

p3相對于p1的偏離邊為(2,4)

3）偏離路徑

p3相對于p1的(2,4,5)

4.KSP算法分類

1）一般KSP問題

對路徑沒有任何限制

2）限定無環KSP問題

要求所有路徑都是簡單路徑，不能有環

當路徑中所有節點都不同時，稱為無環路徑

兩類KSP問題具有不同的特征，分別提出了不同的求解算法，分別稱之為

一般的KSP算法
限定無環KSP算法

K最短路徑算法分類

二、思路

下面列出用Yen's算法求KSP的代碼。該算法是Yen在1971年提出的以其名字命名的Yen算法。算法采用了遞推法中的偏離路徑算法思想，適用于非負權邊的有向無環圖。

1.流程圖

Q：將什么樣的點做為偏離點

在pk的基礎上求pk+1時，將pk的路徑上除終點d之外的節點分別作為偏離點

Q：求Vi到終點d的最短路徑

設起點為s，終點為t，偏離點為Vi。求偏離點到終點的最短路徑時要注意兩個問題

防止從起點到終點的整體路徑有環
從Vi到t的最短路徑不能包含s到Vi的路徑上的任何節點
避免與已經在結果列表中的路徑重復
從Vi發出的邊不能與結果列表中的路徑p1,p2,...pk，上從Vi發出邊的相同

這個體現在代碼上就是：在用Dijkstra算法算最短路徑時對數組的初始化要進行特別處理

// 不能走的邊
if (unavailableEdges != null && unavailableEdges.size() != 0) {
    for (MyPath p: unavailableEdges) {
        int index = p.path.indexOf(startIndex);
        if (index >= 0 && (index + 1) >= 0) {
            dist[index + 1] = Double.MAX_VALUE;
            path[index + 1] = -1;
        }
    }
}

// 不能走的點
if (unavailableNodeIndexs != null && unavailableNodeIndexs.size() != 0) {
    for (Integer point: unavailableNodeIndexs) {
        set[point] = 1;
    }
}

Q：每次找到新的最短路徑時，需將該路徑從候選鏈列表中移除，并加入到結果列表中

Q：候選列表中的路徑不能重復

所以選擇用Set來存儲候選路徑，去重

Q：如何從候選列表中選出合適的路徑

如果只有一條路徑權值和最小的路：將該路徑返回；
如果路徑權值和最小的路有多條：從其中選出節點數最少的路徑。

2.手工模擬求K最短路徑流程

求C到H的10條最短路徑

節點加載內存后存儲在Node[] nodes數組中，各個節點在數組中的存儲位置如下，下面用各個點的數組下標進行說明。表格中括號中備注為路徑權重。

1）通過最短路徑算法Dijkstra得到C到H的最短路徑

p1=C-E-F-H，即0-2-3-5

2）在`p1`的基礎上求`p2`

遍歷完各個偏離點后的情況：

從集合B中選出路徑0->2->4->5(7)移除，并加入到集合A中，作為p2

3）在`p2`的基礎上求`p3`

遍歷完各個偏離點后的情況：

從集合B中選出路徑0->1->3->5(8)移除，并加入到集合A中，作為p3

4）在`p3`的基礎上求`p4`

遍歷完各個偏離點后的情況：

從集合B中選出路徑0->1->3->5(8)移除，并加入到集合A中，作為p4

5）在`p4`的基礎上求`p5`

遍歷完各個偏離點后的情況：

從集合B中選出路徑0->2->3->4->5(8)移除，并加入到集合A中，作為p5`

6）在`p5`的基礎上求`p6`

遍歷完各個偏離點后，沒有新的候選路徑加入集合B中

從集合B中選出路徑0->1->3->4->5(11)移除，并加入到集合A中，作為p6

7）在`p6`的基礎上求`p7`

遍歷各個偏離點時求最短路徑均不存在，故遍歷完各個偏離點后，沒有新的候選路徑加入集合B中，從集合B中選出路徑0->2->1->3->4->5(11)移除，并加入到集合A中，作為p7

8）在`p7`的基礎上求`p8`

遍歷各個偏離點時求最短路徑均不存在，故遍歷完各個偏離點后，沒有新的候選路徑加入集合B中，候選集合為空，不能再繼續向下尋找。故從C到H共有7條路徑。

三、代碼

1.輸入上述圖

2.代碼

package road;

import util.NavigationUtil;

import java.util.*;

/**
 * <pre>
 *     author : 楊麗金
 *     time   : 2018/11/14
 *     desc   : 有關于圖的最短路徑
 *     version: 1.0
 * </pre>
 */
public class ShortestPath {

    public static class MyPath {
        // 路徑上的各個節點對應的數組下標（從起點到終點）
        public List < Integer > path;
        // 路徑總權值
        public double weight;
        // 路徑上節點個數：通過path.size()得到


        public MyPath() {}

        public MyPath(List < Integer > path, double weight) {
            this.path = path;
            this.weight = weight;
        }

        @Override
        public String toString() {
            return "MyPath{" +
                "path=" + path +
                ", weight=" + weight +
                '}';
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;

            MyPath path1 = (MyPath) o;
            return path != null ? path.equals(path1.path) : path1.path == null;
        }

        @Override
        public int hashCode() {
            int result;
            long temp;
            result = path != null ? path.hashCode() : 0;
            temp = Double.doubleToLongBits(weight);
            result = 31 * result + (int)(temp ^ (temp >>> 32));
            return result;
        }
    }


    /**
     * 用Yen's KSP算法從圖中找出從startIndex到endIndex的K條最短路徑
     *
     * @param g
     * @param startIndex:起始節點的數組下標
     * @param endIndex：終止節點的數組下標
     * @param K：要求的最短路徑數目
     * @return
     */
    public List < MyPath > KSP_Yen(MyGraph g, int startIndex, int endIndex, int K) {
        // 結果列表
        List < MyPath > result = new ArrayList < > ();
        // 候選路徑列表
        Set < MyPath > candidatePaths = new HashSet < > ();
        // 候選路徑列表中權值最小的路徑，及其對應的節點個數
        // 第一條最短路徑
        MyPath p1 = getSingleShortestPath_dijkstra(g, startIndex, endIndex, null, null);
        result.add(p1);
        int k = 1;
        List < Integer > pk = p1.path;
        while (k < K) {
            /*
            求第k+1條最短路徑
             */
            // 遍歷每一個偏離點
            for (int i = 0; i <= pk.size() - 2; i++) {
                // 1，pk路徑中起點到偏離點Vi的路徑權值
                double w1 = 0;
                for (int j = 0; j <= i - 1; j++) {
                    w1 += NavigationUtil.getEdgeWight(g, pk.get(j), pk.get(j + 1));
                }
                // 2,偏離點到終點的最短路徑
                MyPath viToDestinationSP = getSingleShortestPath_dijkstra(g,
                    pk.get(i), endIndex, pk.subList(0, i), result);
                if (viToDestinationSP != null) {
                    // 說明從這個偏離點可以到達終點
                    MyPath temp = new MyPath();
                    List < Integer > tempPath = new ArrayList < > (pk.subList(0, i));
                    tempPath.addAll(viToDestinationSP.path);
                    temp.path = tempPath;
                    temp.weight = w1 + viToDestinationSP.weight;
                    // 加入候選列表
                    if (!candidatePaths.contains(temp)) {
                        candidatePaths.add(temp);
                    }
                }
            }
            if (candidatePaths == null || candidatePaths.size() == 0) {
                // 沒有候選路徑，則無需再繼續向下求解
                break;
            } else {
                // 從候選路徑中選出最合適的一條，移除并加入到結果列表
                MyPath fitPath = getFitPathFromCandidate(candidatePaths);
                candidatePaths.remove(fitPath);
                result.add(fitPath);
                k++;
                pk = fitPath.path;
            }
        }
        return result;
    }

    /**
     * 從候選列表中得到一條路徑作為pk+1
     * 要求：1）該路徑的權值和最小；2）路徑經過節點數最少
     * @param candidatePaths：候選列表
     * @return
     */
    private MyPath getFitPathFromCandidate(Set < MyPath > candidatePaths) {
        MyPath result = new MyPath(null, Double.MAX_VALUE);
        for (MyPath p: candidatePaths) {
            // 對于每一條路徑
            if (p.weight < result.weight) {
                result = p;
            }
            if (p.weight == result.weight && p.path.size() < result.path.size()) {
                result = p;
            }
        }
        return result;
    }

    /**
     * 用Dijkstra算法得到從startIndex到endIndex的一條最短路徑
     *
     * @param g
     * @param startIndex                               起始節點的數組下標
     * @param endIndex                                 終止節點的數組下標
     * @param unavailableNodeIndexs：求最短路徑時不可用的節點（數組下標）
     * @param unavailableEdges：求最短路徑時不可用的邊
     * @return
     */
    public MyPath getSingleShortestPath_dijkstra(MyGraph g, int startIndex, int endIndex,
        List < Integer > unavailableNodeIndexs, List < MyPath > unavailableEdges) {
        if (startIndex == -1) {
            //            throw new Exception("getSingleShortestPath_dijkstra()起始點編號輸入錯誤");
        }
        if (endIndex == -1) {
            //            throw new Exception("getSingleShortestPath_dijkstra()終止點編號輸入錯誤");
        }
        int[] set = new int[g.n]; // 是否已并入集合，該點是否已找到最短路徑
        // s到i的最短路徑長度
        double[] dist = new double[g.n];
        // s到i的最短路徑上i的前一個節點編號
        int[] path = new int[g.n];

        // 初始化數組
        set[startIndex] = 1;
        for (int i = 0; i < g.n; i++) {
            if (i == startIndex) { // 源點
                dist[i] = 0;
                path[i] = -1;
            } else {
                if (NavigationUtil.isConnected(g, startIndex, i)) {
                    dist[i] = NavigationUtil.getEdgeWight(g, startIndex, i);
                    path[i] = startIndex;
                } else {
                    dist[i] = Double.MAX_VALUE;
                    path[i] = -1;
                }
            }
        }

        // 不能走的邊
        if (unavailableEdges != null && unavailableEdges.size() != 0) {
            for (MyPath p: unavailableEdges) {
                int index = p.path.indexOf(startIndex);
                if (index >= 0 && (index + 1) >= 0) {
                    dist[p.path.get(index + 1)] = Double.MAX_VALUE;
                    path[p.path.get(index + 1)] = -1;
                }
            }
        }

        // 不能走的點
        if (unavailableNodeIndexs != null && unavailableNodeIndexs.size() != 0) {
            for (Integer point: unavailableNodeIndexs) {
                set[point] = 1;
            }
        }

        // 需進行n-2輪循環
        for (int i = 0; i < g.n - 2; i++) {
            int k = -1;
            double min = Double.MAX_VALUE;
            // 找出dist[]中最小的（太貪心了）
            for (int j = 0; j < g.n; j++) {
                if (set[j] == 1) {
                    continue;
                }
                if (dist[j] < min) {
                    min = dist[j];
                    k = j;
                }
            }
            if (k == -1) {
                // 說明從源點出發與其余節點不連通，無法再向下進行擴展
                break;
            }
            set[k] = 1; // 把節點k并入
            // 修改dist[]、path[]
            for (int j = 0; j < g.n; j++) {
                if (set[j] == 1) {
                    continue;
                }
                if (NavigationUtil.isConnected(g, k, j)) {
                    double temp = dist[k] + NavigationUtil.getEdgeWight(g, k, j);
                    if (temp < dist[j]) {
                        dist[j] = temp;
                        path[j] = k;
                    }
                }
            }
        }

        System.out.println("運行Dijkstra算法后的數組情況為：");
        System.out.print("set[]:");
        for (int i = 0; i < g.n; i++) {
            System.out.print(set[i] + "\t");
        }
        System.out.println();
        System.out.print("dist[]:");
        for (int i = 0; i < g.n; i++) {
            System.out.print(dist[i] + "\t");
        }
        System.out.println();
        System.out.print("path[]:");
        for (int i = 0; i < g.n; i++) {
            System.out.print(path[i] + "\t");
        }
        System.out.println();
        // 輸出
        if (dist[endIndex] == Double.MAX_VALUE) {
            // 說明沒有最短路徑，兩點不連通
            System.out.println("兩點之間不連通");
            return null;
        } else {
            System.out.println("節點" + g.nodes[startIndex].nodeId + "到節點" +
                g.nodes[endIndex].nodeId + "的最短路徑長度為：" + dist[endIndex] + "，具體路徑是：");
            MyPath result = new MyPath();
            result.path = getMinimumPath(g, startIndex, endIndex, path);
            result.weight = dist[endIndex];
            return result;
        }
    }

    /**
     * 輸出從節點S到節點T的最短路徑
     *
     * @param sIndex：起始節點在數組中下標
     * @param tIndex：終止節點在數組中下標
     */
    private List < Integer > getMinimumPath(MyGraph g, int sIndex, int tIndex, int[] path) {
        List < Integer > result = new ArrayList < > ();
        Stack < Integer > stack = new Stack < > ();
        stack.push(tIndex);
        int i = path[tIndex];
        while (i != -1) {
            stack.push(i);
            i = path[i];
        }
        while (!stack.isEmpty()) {
            System.out.print(g.nodes[stack.peek()].nodeId + ":" + g.nodes[stack.peek()].nodeName + "-->");
            result.add(NavigationUtil.getIndex(g, g.nodes[stack.pop()].nodeId));
        }
        System.out.println();
        return result;
    }


}

3.輸出

sps: [MyPath {
    path = [0, 2, 3, 5], weight = 5.0
}, MyPath {
    path = [0, 2, 4, 5], weight = 7.0
}, MyPath {
    path = [0, 1, 3, 5], weight = 8.0
}, MyPath {
    path = [0, 2, 1, 3, 5], weight = 8.0
}, MyPath {
    path = [0, 2, 3, 4, 5], weight = 8.0
}, MyPath {
    path = [0, 1, 3, 4, 5], weight = 11.0
}, MyPath {
    path = [0, 2, 1, 3, 4, 5], weight = 11.0
}]

參考文獻

[1]K條最短路徑問題綜述
[2]韓海玲. 基于城市路網的最短路徑算法研究與應用[D]. 中北大學, 2017.
[3]徐濤, 丁曉璐, 李建伏. K最短路徑算法綜述[J]. 計算機工程與設計, 2013, 34(11):3900-3906.
[4]K條最短路徑算法(KSP, k-shortest pathes)：Yen's Algorithm

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

Yen的K條最短路徑算法（KSP）

Yen的K條最短路徑算法（KSP）

一、問題介紹

1.求K條最短路徑的必要性

2.KSP問題定義

3.相關概念

1）偏離點

2）偏離邊

3）偏離路徑

4.KSP算法分類

1）一般KSP問題

2）限定無環KSP問題

二、思路

1.流程圖

Q：將什么樣的點做為偏離點

Q：求Vi到終點d的最短路徑

Q：每次找到新的最短路徑時，需將該路徑從候選鏈列表中移除，并加入到結果列表中

Q：候選列表中的路徑不能重復

Q：如何從候選列表中選出合適的路徑

2.手工模擬求K最短路徑流程

1）通過最短路徑算法Dijkstra得到C到H的最短路徑

2）在`p1`的基礎上求`p2`

3）在`p2`的基礎上求`p3`

4）在`p3`的基礎上求`p4`

5）在`p4`的基礎上求`p5`

6）在`p5`的基礎上求`p6`

7）在`p6`的基礎上求`p7`

8）在`p7`的基礎上求`p8`

三、代碼

1.輸入上述圖

2.代碼

3.輸出

參考文獻

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

Yen的K條最短路徑算法（KSP）

一、問題介紹

1.求K條最短路徑的必要性

2.KSP問題定義

3.相關概念

1）偏離點

2）偏離邊

3）偏離路徑

4.KSP算法分類

1） 一般KSP問題

2） 限定無環KSP問題

二、思路

1.流程圖

Q：將什么樣的點做為偏離點

Q：求Vi到終點d的最短路徑

Q：每次找到新的最短路徑時，需將該路徑從候選鏈列表中移除，并加入到結果列表中

Q：候選列表中的路徑不能重復

Q：如何從候選列表中選出合適的路徑

2.手工模擬求K最短路徑流程

1）通過最短路徑算法Dijkstra得到C到H的最短路徑

2）在p1的基礎上求p2

3）在p2的基礎上求p3

4）在p3的基礎上求p4

5）在p4的基礎上求p5

6）在p5的基礎上求p6

7）在p6的基礎上求p7

8）在p7的基礎上求p8

三、代碼

1.輸入上述圖

2.代碼

3.輸出

參考文獻

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

1）一般KSP問題

2）限定無環KSP問題

2）在`p1`的基礎上求`p2`

3）在`p2`的基礎上求`p3`

4）在`p3`的基礎上求`p4`

5）在`p4`的基礎上求`p5`

6）在`p5`的基礎上求`p6`

7）在`p6`的基礎上求`p7`

8）在`p7`的基礎上求`p8`