圖 - 最短路徑

　　從一個頂點到達另外一個頂點的成本最小的路徑。

 

　　

 

 

　　咱們採用一個通常性的模型，即加權有向圖。在加權有向圖中，每條有向路徑都有一個與之關聯的路徑權重，它是路徑中的全部邊的權重之和。這種重要的度量方式使得咱們可以將這個問題概括爲 「找到有個頂點到達另外一個頂點的權重最小的有向路徑」。

 

　　單點最短路徑。給定一幅加權有向圖和一個起點 s ，「從 s 到給定的目的頂點 v 是否存在一條有向路徑？若是有，找出最短（總權重最小）的那條路徑」。

　　相關問題：

　　1.加權有向圖的 API 和實現以及單點最短路徑的 API；

　　2.解決邊的權重非負的最短路徑問題的經典 Dijkstra 算法；

　　3.在無環加權有向圖中解決該問題的一種快速方法，邊的權重能夠是負數；

　　4.適用於通常狀況的經典 Bellman-Ford 算法，其中圖能夠含有環，邊的權重也能夠是負數；

　　還須要算法來找出負權重的環，以及不含有這種環的加權有向圖中的最短路徑。

 

　　1.最短路徑的性質

　　1.路徑是有向的。最短路徑須要考慮各條邊的方向。

　　2.權重不必定等價於距離。

　　3.並非全部頂點都是可達的。爲了簡化問題，這裏的樣圖都是強連通的。

　　4.負權重會使問題更復雜。

　　5.最短路徑通常都是簡單的。這裏的算法會忽略構成環的零權重邊，所以找到的最短路徑都不會含有環。

　　6.最短路徑不必定是唯一的。從一個頂點到達另外一個頂點的最短路徑可能有多條，咱們只要找到其中一條便可。

　　7.可能存在平行邊和自環。平行邊中權重最小的邊纔會被選中，最短路徑也不可能包含自環，除非自環的權重爲零，但會忽略它。

 

　　最短路徑

　　咱們的重點是單點最短路徑問題，其中給出起點 s ，計算的結果是一棵最短路徑樹（SPT），它包含了頂點 s 到全部可達的頂點的最短路徑。

 

 

　　這樣一棵樹必定存在的：通常來講，從 s 到一個頂點有可能存在兩條長度相等的路徑，能夠刪除其中一條路徑的最後一條邊。如此這般，直到從起點到每一個頂點都只有一條路徑相連（即一棵樹）。經過構造這棵最短路徑樹，能夠爲用例提供從 s 到圖中任何頂點的最短路徑，表示方法爲一組指向父結點的連接。

 

　　2.加權有向圖的數據結構

　　

　　加權有向圖邊的API

　　

 

 

public class DirectedEdge
    {
        private int v;//邊的起點
        private int w;//邊的終點
        private double weight;//邊的權重

        public DirectedEdge(int v,int w,double weight)
        {
            this.v = v;
            this.w = w;
            this.weight = weight;
        }

        public double Weight()
        {
            return weight;
        }

        public int From()
        {
            return v;
        }

        public int To()
        {
            return w;
        }
    }

 

 

　　加權有向圖的API

　　

 

 

　　

    public class EdgeWeightedDigraph
    {
        private int v;//頂點總數
        private int e;//邊的總數
        private List<DirectedEdge>[] adj;//鄰接表

        public EdgeWeightedDigraph(int v)
        {
            this.v = v;
            this.e = 0;
            adj = new List<DirectedEdge>[v];

            for (int i = 0; i < v; i++)
            {
                adj[i] = new List<DirectedEdge>();
            }
        }

        public int V()
        {
            return v;
        }

        public int E()
        {
            return e;
        }

        public void AddEdge(DirectedEdge _e)
        {
            adj[_e.From()].Add(_e);
            e++;
        }

        public IEnumerable<DirectedEdge> Adj(int v)
        {
            return adj[v];
        }

        public IEnumerable<DirectedEdge> Edges()
        {
            List<DirectedEdge> edges = new List<DirectedEdge>();
            foreach (var _adj in adj)
            {
                edges.AddRange(_adj);
            }

            return edges;
        }
    }

 

　　

 

 

 

　　最短路徑的API

 

 

　　最短路徑的數據結構

　　　

 

 

　　最短路徑樹中的邊。和深度優先搜索，廣度優先搜索同樣，使用一個頂點索引的 DirectedEdge 對象的父連接數組 edgeTo[ ] ，其中 edgeTo[v] 的值爲樹中鏈接 v 和它的父結點的的邊（也是從 s 到 v 的最短路徑上的最後一條邊）。

　　到達起點的距離。咱們須要一個由頂點索引的數組 distTo[ ] ，其中 distTo[v] 爲從 s 到 v 的已知最短路徑的長度。

 

　　咱們約定，edgeTo[s] 的值爲 null，distTo[s] 的值爲 0，從起點到不可達的頂點的距離爲 Double.MaxValue。

 

　　邊的鬆弛

　　咱們的最短路徑 API 的實現都基於一個被稱爲鬆弛（relaxation）的簡單操做。一開始咱們只知道圖的邊和它們的權重，distTo[ ] 中只有起點所對應的元素的值爲 0 ，其他元素的值均被初始化爲 Double.MaxValue 。 隨着算法的執行，它將起點到其餘頂點的最短路徑信息存入 edgeTo[ ] 和 distTo[ ] 數組。在遇到新的邊時，經過更新這些信息就能夠獲得最短路徑。特別是，咱們在其中會用到邊的鬆弛技術，定義爲：放鬆邊 v -> w 意味着檢查從 s 到 w 的最短路徑是不是先從 s 到 v，而後再由 v 到 w 。若是是，則根據這個狀況更新數據結構的內容。由 v 到 w 的最短路徑是 distTo[v] 與 e.Weight() 之和 —— 若是這個值不小於 distTo[w] ，則這條邊失效並忽略。

private void Relax(DirectedEdge e)
{
    int v = e.From(), w = e.To();
    if(distTo[w] > distTo[v] + e.Weight())
    {
        distTo[w] = distTo[v] + e.Weight();
        edgeTo[w] = e;
    }
}    

 

　　下圖是邊的放鬆操做以後可能出現兩種狀況。一種狀況是邊失效（左邊），不更新任何數據；另外一種狀況是 v -> w 就是到達 w 的最短路徑（右邊），這將會更新 edgeTo[w] 和 distTo[w] （這可能會使另外一些邊失效，但也可能產生一些新的有效邊）。

 

　　頂點的鬆弛

　　實際上，實現會放鬆從一個給定頂點指出的全部邊。從任意 distTo[v] 爲有限值的頂點 v 指向任意 distTo[ ] 爲無窮的頂點的邊都是有效的。若是 v 被放鬆，那麼這些有效邊都會被添加到 edgeTo[ ] 中。某條從起點指出的邊將會是第一條被加入 edgeTo[ ] 中的邊。算法會謹慎選擇 頂點，使得每次頂點鬆弛操做都能得出到達某個頂點的更短路徑，最後逐漸找出到達每一個頂點的最短路徑。

private void Relax(EdgeWeightDigraph G,int v)
{
     foreach(DirectedEdge e in G.Adj(v))
     {
          int w = e.To();
          if(distTo[w] > distTo[v] + e.Weight())
          {
               distTo[w] = distTo[v] + e.Weight();
               edgeTo[w] = e;
          }
     }  
}

 

　　3.最短路徑算法的理論基礎

　　邊的放鬆一項很是容易實現的重要操做，它是實現最短路徑算法的基礎。同時，它也是理解這個算法的理論基礎並使咱們可以完整地證實算法的正確性。

 

　　最優性條件

　　最短路徑的最優性條件：令 G 爲一幅加權有向圖，頂點 s 是 G 中的起點，distTo[ ]  是一個由頂點索引的數組，保存的是 G 中路徑的長度。對於從 s 可達的全部頂點 v ，distTo[v] 的值是從 s 到 v 的某條路徑的長度，對於從 s 不可達的全部頂點  v ,該值爲無窮大。當且僅當對於從 v 到 w 的任意一條邊 e ，這些值都知足 distTo[w] <= distTo[v] + e.Weight() 時（換句話說，不存在有效邊時），它們是最短路徑的長度。

 

　　驗證

　　上面最優性條件的一個重要的實際應用是最短路徑的驗證。不管一種算法會如何計算 distTo[ ] ，都只須要遍歷圖中的全部邊一邊並檢查最優性條件是否知足就可以知道該數組中的值是不是最短路徑的長度。最短路徑的算法可能會很複雜，所以可以快速驗證計算的結果就很重要。後面會有 Check（） 方法。

 

　　通用算法

　　通用最短路徑算法：將 distTo[s] 初始化爲 0 ，其餘 distTo[ ] 元素初始化爲無窮達，繼續以下操做：

　　　　放鬆 G 中的任意邊，直到不存在有效邊爲止。

　　對於任意從  s 可達的頂點 w ，在進行這些操做以後，distTo[w] 的值即爲從 s 到 w 的最短路徑的長度且 edgeTo[w] 的值即爲該路徑上的最後一條邊。

　　證實：放鬆邊 v -> w 必然會將 distTo[w] 的值設爲從 s 到 w 的某條路徑的長度且將 edgeTo[w] 設爲該路徑上的最後一條邊。對於從 s 可達的任意頂點 w，只要 distTo[w] 仍然是無窮達，到達 w 的最短路徑上的某條邊確定仍然是有效的，所以算法的操做會不斷繼續，直到由 s 可達的每一個頂點的 distTo[ ] 值均變爲到達頂點的某條路徑的長度。對於已經找到最短路徑的任意頂點 v ，在算法的計算過程當中 distTo[v] 的值都是從 s 到 v 的某條路徑的長度且必然是單調遞減的。所以，它遞減的次數必然是有限的（每切換一條 s 到 v 簡單路徑就遞減一次）。當不存在有效邊的時候，最優性條件就成立了。

 

　　將最優性條件和通用算法放在一塊兒討論的關鍵緣由是，通用算法並無指定邊的放鬆順序。所以，要證實這些算法都能經過計算獲得最短路徑，只須要證實它們都會放鬆全部的邊直到全部邊都失效便可。

 

　　4.Dijkstra 算法

　　在最小生成樹中，分享了尋找加權無向圖中的最小生成樹的 Prim 算法：構造最小生成樹的每一步都向這棵樹中添加一條新的邊。Dijkstra 算法採用了相似的方法來計算最短路徑樹。首先將 distTo[s] 初始化爲 0，distTo[ ] 中的其餘元素初始化爲正無窮大。而後將 distTo[ ] 最小的非樹頂點放鬆並加入樹中，如此這般，直到全部的頂點都在樹中或者全部的非樹頂點的 distTo[ ] 值均爲無窮大。

　　Dijkstra 算法可以解決邊權重非負的加權有向圖的單起點最短路徑問題。證實：若是 v 是從起點可達的，那麼全部 v -> w 的邊都只會被放鬆一次。當 v 被放鬆時，必有 distTo[w] <= distTo[v] + e.Weight() 。該不等式在算法結束前都會成立，所以 distTo[v] 則不會改變（由於邊的權重非負且在每一步中算法都會選擇 distTo[ ] 最小的頂點，以後的放鬆操做不可能使任何 distTo[ ] 的值小於 distTo[v]）。所以，在全部從 s 可達的頂點均被添加到樹中以後，最短路徑的最優性條件成立。

 

 　　數據結構

　　要實現 Dijkstra 算法，除了 distTo[ ]  和 edgeTo[ ] 數組以外還須要一條索引優先隊列 pq ，以保存須要被放鬆的頂點。 IndexMinPQ 能夠將索引和鍵（優先級）關聯起來而且能夠刪除並返回優先級最低的索引。在這裏，只要將頂點 v 和 distTo[v] 關聯起來就當即能夠獲得 Dijkstra 算法的實現。edgeTo[ ] 中的元素所對應的可達頂點構成了一棵最短路徑樹。

 

　　以下圖，根據算法的證實，已知樹節點所對應的 distTo[ ] 值均爲最短路徑的長度。對於優先隊列中的任意頂點 w ，distTo[w] 是從 s 到 w 的最短路徑的長度，該路徑上的中間頂點在樹中且路徑結束於橫切邊 edgeTo[w] 。優先級最小的頂點的 distTo[ ] 值就是最短路徑的權重，它不會小於已經放鬆過的任意頂點的最短路徑的權重，也不會大於還未被放鬆過的任意頂點的最短路徑的權重。這個頂點就是下一個要被放鬆的頂點。全部從 s 可達的頂點都會按照最短路徑的權重順序被放鬆。

 

　　實現

    public class DijkstraSP
    {
        private DirectedEdge[] edgeTo;
        private double[] distTo;
        private IndexMinPQ<Double> pq;

        public DijkstraSP(EdgeWeightedDigraph G,int s)
        {
            edgeTo = new DirectedEdge[G.V()];
            distTo = new double[G.V()];
            pq = new IndexMinPQ<double>(G.V());

            for (int v = 0; v < G.V(); v++)
            {
                distTo[v] = Double.MaxValue;
            }

            distTo[0] = 0.0;
            pq.Insert(s,0.0);
            while (!pq.IsEmpty())
            {
                Relax(G,pq.DelMIn());
            }
        }

        private void Relax(EdgeWeightedDigraph G, int v)
        {
            foreach (var e in G.Adj(v))
            {
                int w = e.To();
                if (distTo[w] > distTo[v] + e.Weight())
                {
                    distTo[w] = distTo[v] + e.Weight();
                    edgeTo[w] = e;

                    if (pq.Contains(w))
                    {
                        pq.Change(w, distTo[w]);
                    }
                    else
                    {
                        pq.Insert(w,distTo[w]);
                    }

                }
            }
        }
    }

　　

　　軌跡

　　1.將頂點 0 添加到樹中，將頂點 2 和 4 加入優先隊列；

　　2.從優先隊列中刪除頂點 2，將 0 -> 2 添加到樹中，將頂點 7 加入優先隊列；

　　3.從優先隊列中刪除頂點 4，將 0 -> 4 添加到樹中，將頂點 5 加入優先隊列，邊 4 -> 7 失效；

　　4.從優先隊列中刪除頂點 7，將  2 -> 7添加到樹中，將頂點 3 加入到優先隊列，邊 7 -> 5 失效；

　　5.從優先隊列中刪除頂點 5，將 4 -> 5添加到樹中，將頂點 1 加入優先隊列，邊 5 -> 7 失效；

　　6.從優先隊列中刪除頂點 1，將 5 -> 1添加到樹中，邊 1 -> 3 失效；

　　7.從優先隊列中刪除頂點 6，將 3 -> 6 添加到樹中。　

　　

　　算法按照頂點到起點的最短路徑的長度的增序將它們添加到最短路徑樹中。

 

 

 

　　在一幅含有 V 個頂點和 E 條邊的加權有向圖中，使用 Dijkstra 算法計算結點爲給定起點的最短路徑樹所需的空間與 V 成正比，時間與 ElogV 成正比（最壞狀況下）。　　

 

 　　變種

 　　只需對 Dijkstra 算法的實現稍做修改就能解決這個問題的其餘版本。例如，加權無向圖中的單點最短路徑。

　　若是將無向圖看作有向圖，建立一幅由相同頂點構成的加權有向圖，且對於無向圖中的每條邊，相應地建立兩條方向不一樣的有向邊。有向圖中的路徑和無向圖中的路徑存在一一對應的關係，路徑的權重也是相同的——最短路徑的問題是等價的。

 

　　給定兩點的最短路徑。

　　給定一幅加權有向圖以及一個起點 s 和一個終點 t，找到從 s 到 t 的最短路徑。 

　　要解決這個問題，可使用 Dijkstra 算法並在從優先隊列中取到 t 以後終止搜索。

 

　　任意頂點對之間的最短路徑

　　下面的代碼解決了任意頂點對之間的最短路徑問題，所需的時間和空間都與 EVlogV 成正比。它構造了 DijkstraSP 對象的數組，每一個元素都將相應的頂點做爲起點。在用例進行查詢時，代碼會訪問起點所對應的單點最短路徑對象並將目的頂點做爲參數進行查詢。

    public class DijkstraAllPairsSP
    {
        private DijkstraSP[] all;

        public DijkstraAllPairsSP(EdgeWeightedDigraph G)
        {
            all = new DijkstraSP[G.V()];
            for (int v = 0; v < G.V(); v++)
            {
                all[v] = new DijkstraSP(G,v);
            }
        }

        public IEnumerable<DirectedEdge> Path(int s, int t)
        {
            return all[s].Path(t);
        }

        public double Dist(int s, int t)
        {
            return all[s].Dist(t);
        }
    }

 

　　歐幾里得圖中的最短路徑

　　在頂點爲平面上的點且邊的權重於頂點歐幾里得間距成正比的圖中，解決單點，給定兩點和任意頂點對之間的最短路徑。

　　下圖是Dijkstra 算法在處理歐幾里得圖時用若干不一樣的起點產生最短路徑樹的過程。

 

 

　　下面，將會考慮加權無環圖中的最短路徑算法而且將在線性時間內解決該問題。而後是負權重的加權有向圖中的最短路徑問題，Dijkstra 算法並不適用於這種狀況。

 

　　5.無環加權有向圖中的最短路徑算法

 　　許多應用中的加權有向圖都是不含有有向環的。如今來看一種比 Dijkstra 算法更快，更簡單的在無環加權有向圖中找出最短路徑的算法，它的特色是：

　　1.可以在線性時間內解決單點最短路徑的問題；

　　2.可以處理負權重的邊；

　　3.可以解決相關的問題，例如找出最長的路徑。

　　這種算法是在有向圖中學過的無環有向圖的拓撲排序算法的簡單擴展。

 

　　特別的是，只要將頂點的放鬆和拓撲排序結婚起來，立刻就可以獲得一種解決無環加權有向圖中的最短路徑問題 的算法。首先，將 distTo[s] 初始化爲 0 ，其餘 distTo[ ]  元素初始化爲無窮大，而後一個一個地按照拓撲順序放鬆全部頂點。

 

　　命題 S ：按照拓撲順序放鬆頂點，就能在和 E+V 成正比的時間內解決無環加權有向圖的單點最短路徑問題。每條邊 v --> w 都只會被放鬆一次。當 v 被放鬆時，獲得：distTo[w] <= distTo[v] + e.Weight() 。在算法結束前該不等式都成立，由於 distTo[v] 是不會變化的（由於是按照拓撲順序放鬆頂點，在 v 被放鬆以後算法不會再處理任何指向 v 的邊）而 distTo[w] 只會變小（任何放鬆操做都只會減少 distTo[ ] 中元素的值）。所以，在全部從 s 可達的頂點都被加入到樹中後，最短路徑的最優性條件成立。

namespace ShortestPaths
{
    /// <summary>
    /// 基於拓撲的無環加權有向圖的最短路徑算法
    /// </summary>
    public class AcyclicSP
    {
        private DirectedEdge[] edgeTo;
        private double[] distTo;

        public AcyclicSP(EdgeWeightedDigraph G, int s)
        {
            edgeTo = new DirectedEdge[G.V()];
            distTo = new double[G.V()];

            for (var i = 0; i < G.V(); i++)
            {
                distTo[i] = Double.MaxValue;
            }
            distTo[0] = 0;

            Topological top = new Topological(G);
            foreach (var v in top.Order())
            {
                Relax(G,v);
            }
        }

        private void Relax(EdgeWeightedDigraph G, int v)
        {
            foreach (DirectedEdge e in G.Adj(v))
            {
                int w = e.To();
                if (distTo[w] > distTo[v] + e.Weight())
                {
                    distTo[w] = distTo[v] + e.Weight();
                    edgeTo[w] = e;
                }
            }
        }
    }
}

 

　　示例軌跡：

　　1.用深度優先搜索獲得圖的頂點的拓撲排序 5 1 3 6 4 7 0 2；

　　2.將頂點 5 和從它指出的全部邊添加到樹中；

　　3.將頂點 1 和邊 1->3 添加到樹中；

　　4.將頂點 3 和邊 3->6 添加到樹中，邊 3->7 失效；

　　5.將頂點 6 和邊 6->2, 6->0 添加到樹中，邊 6->4 失效；

　　6.將頂點 4 和邊 4->0 添加到樹中，邊 4->7 和 6->0 失效；

　　7.將頂點 7 和邊 7->2 添加到樹中，邊 6->2 失效；

　　8.將頂點 0 添加到樹中，邊 0->2 失效；

　　9.將頂點 2 添加到樹中。

　　

 

 　　命題 S 很重要，由於它的 「無環」 可以極大地簡化問題的論斷。對於最短路徑問題，基於拓撲排序的方法比 Diijkstra 算法快的倍數與 Diijkstra 算法中全部優先隊列操做的總成本成正比。另外，命題 S 的證實和邊的權重是否非負無關，所以無環加權有向圖不會受任何限制。用這個特色能夠解決邊的負權重問題。

　　最長路徑

 　　考慮在無環加權有向圖中尋找最長路徑的問題，邊的權重可正可負。

　　實現：複製原始無環加權有向圖獲得一個副本並將副本中的全部邊的權重變爲負值。這樣，副本中的最短路徑即爲原圖中的最長路徑。要將最短路徑問題的答案轉換爲最長路徑問題的答案，只需將方案中的權重變爲正值便可。所需時間與 E+V 成正比。

　　軌跡：

 

 

　　在通常的加權有向圖（邊的權重可能爲負）中尋找最長簡單路徑的已知最好算法在最壞狀況下所需的時間是指數級別。出現環的可能性彷佛使這個問題的難度以指數級別增加。

 

　　並行調度任務 

 　  這裏再次考慮有向圖中出現過的任務調度問題，此次解決一下調度問題：

　　優先級限制下的並行任務調度。給定一組須要完成的任務和每一個任務所需的時間，以及一組關於任務完成的前後次序的優先級限制。在知足限制條件的前提下應該如何在若干相同的處理器（數量不限）安排任務並在最短期內完成全部任務？

　　有向圖中調度的模型默認只有單個處理器：將任務按照拓撲順序排序，完成任務的總耗時就是全部任務所須要的總時間。如今假設有足夠多的處理器並可以同時處理任意多的任務，受到的只有優先級的限制。

　　存在一種線性時間的算法 —— 一種叫作「關鍵路徑」的方法可以證實這個問題與無環加權有向圖中的最長路徑問題是等價的。

 

　　假設任意可用的處理器都能在任務所需的時間內完成它，那麼咱們的重點就是儘早安排每個任務。例如，下面表給出了一個任務調度問題。下圖給出瞭解決方案，顯示了這個問題所需的最短期 173.0 。

　　這份調度方案知足了全部限制條件，沒有其餘調度方案比這耗時更少，由於任務必須按照 0 -> 9 -> 6 -> 8 -> 2 的順序完成。這個順序就是這個問題的關鍵路徑。由優先級限制指定的每一列任務都表明了調度方案的一種可能的時間下限。若是將一系列任務的長度定義爲完成全部任務的最先可能時間，那麼最長的任務序列就是問題的關鍵路徑，由於在這份任務序列中任何任務的啓動延遲都會影響到整個項目的完成時間。

     

 

 

　　解決：

　　解決並行任務調度問題的關鍵路徑方法的步驟以下：建立一幅無環加權有向圖，其中包含一個起點 s 和一個終點 t 且每一個人物都對應着兩個頂點（一個起始頂點和一個結束頂點。對於每一個任務都有一條從它的起始頂點指向結束頂點的邊，邊的權重爲任務所須要的時間。對於每條優先級限制 v -> w ，添加一條從 v 的結束頂點指向 w 的起始頂點的權重爲零的邊。咱們還須要爲每一個任務添加一條從起點指向該任務的起始頂點的權重爲零的邊以及一條從該任務的結束頂點到終點的權重爲零的邊。這樣，每一個任務預計的開始時間即爲從起點到它的起始頂點的最長距離。

　　

 

 　　接下來就是在無環加權有向圖中尋找一個最長路徑——關鍵路徑。

        static void Main(string[] args)
        {
            string[] strs = File.ReadAllLines(@"jobs.txt");
            var N = Int32.Parse(strs[0]);//任務數
            EdgeWeightedDigraph G = new EdgeWeightedDigraph(2*N+2);//2*N+2 爲節點數，每一個任務兩個我節點，再加上起始兩個節點
            int s = 2 * N, t = 2 * N + 1;//起點和終點
            for (var i = 0; i < N; i++)
            {
                string[] a = strs[i].Split(" ");
                double duration = Double.Parse(a[0]);
                G.AddEdge(new DirectedEdge(i,i+N,duration));//任務起點指向任務終點
                G.AddEdge(new DirectedEdge(s,i,0));
                G.AddEdge(new DirectedEdge(i+N,t,0));

                for (var j = 1; j < a.Length; j++)
                {
                    int successor = Int32.Parse(a[j]);
                    G.AddEdge(new DirectedEdge(i+N,successor,0));
                }
            }

            AcyclicSP lp = new AcyclicSP(G,s);
            for (var i = 0; i < N; i++)
                Console.WriteLine($"{i} 開始時間:"+lp.DistTo(i));
            Console.WriteLine("t distTo:" + lp.DistTo(t));

        }

 

 　　這裏實現的任務調度問題的關鍵路徑方法將問題歸約爲尋找無環加權有向圖的最長路徑問題。它會根據任務調度問題的描述用關鍵路徑的方法構造一幅加權有向圖，而後使用 AcylicLP 找到圖中的最長路徑，最後打印出各條最長路徑的長度，也就是正好是每一個任務的開始時間。

　　

 

 

　　解決優先級限制下的並行任務調度問題的關鍵路徑法所需的時間爲線性級別。爲何 CPM 類能解決問題？算法的正確性依賴於兩個因素。首先，在相應的有向無環圖中，每條路徑都是由任務的起始頂點和結束頂點組成的並由權重爲零的優先級限制條件的邊分隔 —— 從起點 s 到任意頂點 v 的任意路徑的長度都是任務 v 的開始 / 結束時間的下限，由於這已是在同一臺處理器上順序完成這些任務的最優的排列順序了。所以，從起點 s 到終點 t 的最長路徑就是全部任務的完成時間的下限。第二，由最長路徑獲得的全部開始和結束時間都是可行的 —— 每一個任務都只能在優先級限制指定的先導任務完成以後開始，由於它的開始時間就是頂點到它的起始頂點的最長路徑的長度。所以，從起點 s 到 終點 t 的最長路徑長度就是全部任務完成時間的上限。

 　　

 

 

　　相對最後期限限制下的並行任務調度

　　通常的最後期限（deadline）都是相對於第一個任務的開始時間而言的。假設在任務調度問題中加入一種新類型的限制，須要某個任務必須在指定的時間點以前開始，即指定和另外一個任務的開始時間的相對時間。這種類型的限制條件在爭分奪秒的生產線上以及許多其餘應用中都很常見，但它也會使得任務調度問題更難解決。以下表，假設要在前面的示例中加入一個限制條件，使 2 號任務必須在 4 號任務啓動後的 12 個時間單位以內開始。實際上，在這裏最後期限限制的是 4 號任務的開始時間：它的開始時間不能早於 2 號任務開始 12 個時間單位。在示例中，調度表中有足夠的空檔來知足這個最後期限限制：咱們能夠令 4 號任務開始於 111 時間，即 2 號任務計劃開始時間前的 12 個時間單位處。須要注意的是，若是 4 號任務耗時很長，這個修改可能會延長整個調度計劃的完成時間。同理，若是再添加一個最後期限的限制條件，令 2 號任務必須在 7 號任務啓動後的 70 個時間單位內開始，還能夠將 7 號任務的開始時間調整到 53，這樣就不用修改 3 號任務和 8 號任務的計劃開始時間。可是若是繼續限制 4 號任務必須在 0 號任務啓動後的 80 個時間單位內開始，那麼就不存在可行的調度計劃了：限制條件 4 號任務必須在 0 號任務啓動後的 80 個時間單位內開始以及 2 號任務必須在 4 號任務啓動後的 12 個時間單位以內開始，意味着 2 號任務必須在 0 號任務啓動後的 93 個時間單位以內開始，但由於存在任務鏈 0（41 個時間單位）-> 9（29 個時間單位）-> 6（21 個時間單位）-> 8（32 個時間單位）-> 2，2 號任務最先也只能在 0 號任務啓動後的 123 個時間單位以內開始。

　　　　

 

　　向任務調度問題中添加的最後期限限制

　　

 

 

　　相對最後期限限制下的並行任務調度問題是一個加權有向圖中的最短路徑問題（可能存在環和負權重邊）。 根據任務調度的描述構造加權有向圖，爲每條最後期限限制添加一條邊：若是任務 v 必須在任務 w 啓動後的 d 個單位時間內開始，則添加條從 v 指向 w 的負權重爲 d 的邊。將全部邊的權重取反便可將該問題轉化爲一個最短路徑問題。若是存在可行的調度方案，證實也就完成了。判斷一個調度方案是否可行也是計算的一部分。

 

　　上面的示例說明了負權重的邊在實際應用的模型中也能起到重要做用。它說明，若是可以有效解決負權重邊的最短路徑問題，那就可以找到相對最後期限限制下的並行任務調度問題的解決方案。以前學過的算法都沒法完成這個任務：Dijkstra 算法只適用於正權重的邊，AcylicSP 算法要求有向圖是無環的。下面解決含有負權重且不必定是無環的有向圖中的最短路徑問題。

 

　　6.通常加權有向圖中的最短路徑問題

　　上面討論的最後期限限制下的任務調度問題告訴咱們負權重的邊不只僅是一個數學問題。相反，它可以極大地擴展解決最短路徑問題模型的應用範圍。接下來，考慮既可能含有環也可能含有負權重的邊的加權有向圖中的最短路徑算法。

　　開始以前，先學習一下這種有向圖的基本性質以及更新咱們對最短路徑的認識。下圖展現的是負權重的邊對有向圖中的最短路徑的影響。也許最明顯的改變就是當存在負權重的邊時，權重較小的路徑含有的邊可能會比權重較大的路徑更多。在只存在正權重的邊時，咱們的重點在於尋找近路；但當存在負權重的邊時，咱們可能會爲了通過負權重的邊而繞遠。這種效應使得咱們要將查找 「最短」 路徑的感受轉變爲對算法本質的理解。所以須要拋棄直覺並在一個簡單，抽象的層面上考慮這個問題。

 

 

 　　嘗試一

 　　第一個想法是先找到權重最小（最小負值）的邊，而後將全部邊的權重加上這個負值的絕對值，這樣原有向圖就轉變成了一幅不含有負權重邊的有向圖。但這種作法不會解決任何問題，由於新圖中的最短路徑和原圖中的最短路徑毫無關係。

 

　　嘗試二 

 　　第二個想法是改造 Dijkstra 算法。這種算法最根本的缺陷在於原算法的基礎在於根據距離起點的遠近依次檢查路徑，添加一條邊會使路徑變得更長。但添加任意負權重的邊只會使得路徑更短。

 

　　負權重的環

　　當咱們在研究含有負權重邊的有向圖時，若是該圖中含有一個權重爲負的環，那麼最短路徑的概念就失去意義了。以下圖，除了邊 5 -> 4 的權重爲 -0.66 外，它和前面的示例徹底相同。這裏，環 4-> 7 -> 5 -> 4 的權重爲：

　　0.37 + 0.28 - 0.66  = -0.01；

　　咱們只要圍着這個環兜圈子就能獲得權重任意短的路徑！注意，有向環的全部邊的權重並不必定都必須是負的，只要權重之和是負的便可。

　　

 

 

　　定義：加權有向圖中的負權重環是一個總權重爲負的有向環。

 

　　如今，假設從 s 到可達的某個頂點 v 的路徑上的某個頂點在一個負權重環上。在這種狀況下，從  s 到 v 的最短路徑是不可能存在的，由於能夠利用這個負權重環構造權重任意小的路徑。換句話說，在負權重環存在的狀況下，最短路徑問題是沒有意義的。

　　

　　當且僅當加權有向圖中至少存在一條從 s 到 v 的有向路徑且全部從 s 到 v 的有向路徑上的任意頂點都不存在於任何負權重環中時，s 到 v 的最短路徑纔是存在的。

　　注意，要求最短路徑上的任意頂點都不存在於負權重環中意味着最短路徑是簡單的，並且與正權重邊的圖同樣都可以獲得此類頂點的最短路徑樹。

 

　　嘗試三

　　不管是否存在負權重環，從 s 到可達的其餘頂點的一條最短的簡單路徑都是存在的。爲何不定義最短路徑以方便尋找呢？可是，已知解決這個問題的最好算法在最壞狀況下所需的時間是指數級別的（後面會降到）。通常來講，這種問題太難了，只會研究它的簡單版本。

　　所以，一個定義明確且能夠解決加權有向圖最短路徑的算法要可以：

 　　1.對於從起點不可達的頂點，最短路徑爲正無窮；

　　2.對於從起點可達但路徑上的某個頂點屬於一個負權重環的頂點，最短路徑爲負無窮；

　　3.對於其餘全部頂點，計算最短路徑的權重。

 

　　從文章的開始到如今，咱們爲最短路徑問題加上了各類限制，使得咱們可以找到解決相應問題的辦法。首先，咱們不容許負權重邊的存在；其次不接受有向環。如今咱們放寬全部這些條件並重點解決通常有向圖中的問題。

　　負權重環的檢測。 給定的加權有向圖中含有負權重環嗎？若是有，找到它。

　　負權重環不可達時的單點最短路徑。給定一幅加權有向圖和一個起點 s 且從 s 瓦法到達任何負權重環。是否存在一條從 s 到給定的頂點 v 的有向路徑？若是有，找出最短的那條路徑。

　　總結。儘管在含有環的有向圖中最短路徑是一個沒有意義的問題，並且也沒法有效解決在這種有向圖中高效找出最短簡單路徑的問題，在實際應用中仍然須要可以識別其中的負權重環。例如，在最後期限限制下的任務調度問題中，負權重環的出現可能相對較少；限制條件和最後期限都是從現實世界中的實際限制得來的，所以負權重環大多可能來自於問題陳述中的錯誤。找出負權重環，改正相應的錯誤，找到沒有負權重環問題的調度方案纔是解決問題的正確方式。在其餘狀況下，找到負權重環就是計算的目標。

 

　　Bellman-Ford 算法可以有效解決這些問題而且一樣適用於正權重邊的有向圖。

　　Bellman-Ford 算法。在任意含有 V 個頂點的加權有向圖中給定起點 s  ，從 s 沒法到達任何負權重環，如下算法可以解決其中的單點最短問題：將 distTo[s] 初始化爲 0 ，其餘 distTo[ ] 元素初始化爲無窮大。以任意順序放鬆有向圖全部邊，重複 V 輪。

　　這個方法很是通用，由於它沒有指定邊的放鬆順序。下面將注意力集中在一個通用性稍遜的方法上，其中只放鬆從任意頂點指定的全部邊（任意順序）：

            for (int pass = 0; pass < G.V(); pass++)
            {
                for (v = 0; v < G.V(); v++)
                {
                    foreach (DirectedEdge e in G.Adj(v))
                        Relax(e);
                }
            }

　　它老是會放鬆 VE 條邊且只需稍做修改便可使算法在通常情景下更高效。

 

　　基於隊列的 Bellman-Ford 算法

　　其實，根據經驗咱們很容易知道在任意一輪中許多邊的放鬆都不會成功：只有上一輪中的 distTo[ ] 值發生變化的頂點指出的邊纔可以改變其餘 distTo[ ] 元素的值。爲了記錄這樣的頂點，咱們使用了一條 FIFO 隊列。算法在處理正權重標準樣圖中進行的操做軌跡以下圖，在圖中，左側是每一輪中隊列中的有效頂點（紅色），緊接着是下一輪中的有效頂點（黑色）。首先將起點加入隊列，而後按照如下步驟計算最短路徑樹：

　　1.放鬆邊 1 -> 3 並將頂點 3 加入隊列；

　　2.放鬆邊 3 -> 6 並將頂點 6 加入隊列；

　　3.放鬆邊 6 -> 4, 6 -> 0 和 6 -> 2 並將頂點 4,0 和 2 加入隊列；

　　4.放鬆邊 4 -> 7，4 -> 5 並將頂點 7 和 5 加入隊列。放鬆已經失效的邊 0 -> 4 和 0 -> 2。而後再放鬆邊 2 -> 7 （並從新爲 4 -> 7 着色）。

　　5.放鬆邊 7 -> 5 （並從新爲 4 -> 5 着色）但不將頂點 5 加入隊列（它已經在隊列中了）。放鬆已經失效的邊 7 -> 3。而後放鬆已經失效的邊 5 -> 1， 5 -> 4 和 5 -> 7。此時隊列爲空。

　　

 　　實現

　　根據上面的描述實現 Bellman-Ford 算法所需的代碼不多，它基於如下兩種其餘的數據結構：

　　1.一條用來保存即將被放鬆的頂點的隊列 Queue；

　　2.一個由頂點索引的 bool 數組 OnQ[ ] ，用來指示頂點是否已經存在於隊列中，以防止將頂點重複加入隊列。

 

　　首先，將起點 s 加入隊列中，而後進入一個循環，其中每次都從隊列中取一個頂點並將其放鬆。要將一個頂點插入隊列，須要修改以前的 Relax 方法實現，以便將被成功放鬆的邊所指向的頂點加入隊列中。這些數據結構可以保證：

　　1.隊列中不會出現重複的頂點；

　　2.在某一輪中，改變了 edgeTo[ ] 和 distTo[ ] 的值得全部頂點都會在下一輪中處理。

　　要完整地實現該算法，咱們就須要保證在 V 輪後算法可以終止。實現它的一種方法是顯式記錄放鬆的輪數。下面的代碼使用了另外一種算法，後面詳細說：它會在有向圖的 edgeTo[ ] 中檢測是否存在負權重環，若是找到則結束運行。

    public class BellmanFordSP
    {
        private double[] distTo;//從起點到某個頂點的路徑長度
        private DirectedEdge[] edgeTo;//從起點到某個頂點的最後一條邊
        private bool[] onQ;//該頂點是否存在於隊列中
        private Queue<int> queue;//正在被放鬆的頂點
        private int cost;//relax 的調用次數
        private IEnumerable<DirectedEdge> cycle;//edgeTo[] 中的是否有負權重環

        public BellmanFordSP(EdgeWeightedDigraph G,int s)
        {
            distTo = new double[G.V()];
            edgeTo = new DirectedEdge[G.V()];
            onQ = new bool[G.V()];
            queue = new Queue<int>();
            for (int v = 0; v < G.V(); v++)
                distTo[v] = Double.MaxValue;
            distTo[s] = 0;
            queue.Enqueue(s);
            onQ[s] = true;
            while (queue.Count != 0 && !HasNegativeCycle())
            {
                int v = queue.Dequeue();
                onQ[v] = false;
                Relax(G,v);
            }
        }

        //負權重環的檢測
        private bool HasNegativeCycle()
        {
            throw new NotImplementedException();
        }

        private void Relax(EdgeWeightedDigraph G, int v)
        {
            foreach (DirectedEdge e in G.Adj(v))
            {
                int w = e.To();
                if (distTo[w] > distTo[v] + e.Weight())
                {
                    distTo[w] = distTo[v] + e.Weight();
                    edgeTo[w] = e;
                    if (!onQ[w])
                    {
                        queue.Enqueue(w);
                        onQ[w] = true;
                    }
                }

                if (cost++ % G.V() == 0)
                    FindNegativeCycle();
            }
        }

        //查找負權重環
        private void FindNegativeCycle()
        {
            throw new NotImplementedException();
        }
    }

　　Relax 方法將成功放鬆的邊指向的全部頂點加入到一條 FIFO 隊列中（隊列中不出現重複的頂點）並周期性地檢查 edgeTo[ ] 表示的子圖中是否存在負權重環。

 

　　對於任意含有 V 個頂點的加權有向圖和給定的起點  s ，在最壞狀況下基於隊列的 Bellman-Ford 算法解決最短路徑問題（或者找到從 s 可達的負權重環）所需的時間與 EV 成正比，空間和 V 成正比。

　　若是不存在從 s 可達的負權重環，算法會在進行 V-1 輪放鬆操做後結束（由於全部最短路徑含有的邊數都小於 V-1）。若是的確存在一個從 s 可達的負權重環，那麼隊列永遠不可能爲空。在第 V 輪放鬆以後，edgeTo[ ] 數組必然會包含一條含有一個環的路徑（從某個頂點 w 回到它本身）且該環的權重必然是負的。由於 w 會在路徑上出現兩次且 s 到 w 的第二次出現處的路徑長度小於 s 到 w 的第一次出現的路徑長度。在最壞狀況下，該算法的行爲和通用算法類似並會將全部的 E 條邊所有放鬆 V 輪。

 

　　基於隊列的 Bellman-Ford 算法對於相同的問題比較路徑長度的次數少於 Disjkstra 算法。 

 

　　負權重的邊

　　下圖顯示了  Bellman-Ford 算法在處理含有負權重邊的有向圖的軌跡。首先將起點加入隊列 queue ，而後按照如下步驟計算最短路徑樹。

　　1.放鬆邊 0 -> 2 和 0 -> 4 並將頂點 2，4 加入隊列。

　　2.放鬆邊 2 -> 7 並將頂點 7 加入隊列。放鬆邊 4 -> 5 並將頂點 5 加入隊列。而後放鬆失效的邊 4 -> 7。

　　3.放鬆邊 7 -> 3 和 5 -> 1 並將頂點 3 和 1 加入隊列。放鬆失效的邊 5 -> 4 和 5 -> 7 。

　　4.放鬆邊 3 -> 6 並將頂點 6 加入隊列。放鬆失效的邊 1 -> 3 。

　　5.放鬆邊 6 -> 4 並將頂點 4 加入隊列。這條負權重的邊使獲得頂點 4 的路徑變短，所以它的邊須要被再次放鬆。從起點到頂點 5 和 1 的距離已經失效並會在下一輪修正。

　　6.放鬆邊 4 -> 5 並將頂點 5 加入隊列。放鬆失效的邊 4 -> 7 。

　　7.放鬆邊 5 -> 1 並將頂點 1 加入隊列。放鬆失效的邊 5 -> 4 和 5 -> 7 。

　　8.放鬆失效的邊 1 -> 3 。隊列爲空。

　　在這個例子中，最短路徑樹就是一條從頂點 0 到頂點 1 的路徑。從頂點 4，5 和 1 指出的全部邊都被放鬆了兩次。

 

 

 

 

　　負權重環的檢測

　　實現 BellmanFordSP 會檢測負權重環來避免陷入無限的循環中。咱們也能夠將這段檢測代碼獨立出來使得用例能夠檢查並獲得負權重環。在 BellmanFordSP 的構造函數運行以後，在將全部邊放鬆 V 輪以後當且僅當隊列非空時有向圖中才存在從起點可達的負權重環。若是是這樣， edgeTo[ ] 數組所表示的子圖必然含有這個負權重環。咱們修改有向圖中的 DirectedCycle 類來在加權有向圖中尋找環。這種檢查的成本分爲如下幾個部分：

　　1.添加一個變量 cycle 和一個私有函數 FindNegativeCycle 。若是找到負權重環，該方法會將 cycle 的值設爲含有環中全部邊的一個迭代器（若是沒有找到則設爲 null）。

　　2.每調用 V 次 Relax 方法後即調用 FindNegativeCycle 方法。

　　這種方法可以保證構造函數中的循環必然終止。另外，用例能夠調用  HasNegativeCycle 來判斷是否存在從起點可達的負權重環。

        //查找負權重環
        private void FindNegativeCycle()
        {
            int V = edgeTo.Length;
            EdgeWeightedDigraph spt;
            spt = new EdgeWeightedDigraph(V);
            for (int v = 0; v < V; v++)
            {
                if (edgeTo[v] != null)
                    spt.AddEdge(edgeTo[v]);
            }

            EdgeWeightedCycleFinder cf;
            cf = new EdgeWeightedCycleFinder(spt);

            cycle = cf.Cycle();
        }

        //負權重環的檢測
        private bool HasNegativeCycle()
        {
            return cycle != null;
        }

        public IEnumerable<DirectedEdge> NegativeCycle()
        {
            return cycle;
        }

　　

　　下圖是 Bellman-Ford 算法在一幅含有負權重環的有向圖中的運行軌跡。頭兩輪放鬆操做與前面的例子同樣，在第三輪中，算法放鬆了邊 7 -> 3 和 5 -> 1 並將頂點 3 和 1 加入隊列後開始放鬆負權重邊 5 -> 4 。在此次放鬆操做中算法發現了一個負權重環 4 -> 5 -> 4 。它將 5 -> 4 加入最短路徑樹中並在 edgeTo[ ] 將環和起點隔離起來。從這時開始，算法沿着環繼續運行並減小到達所遇到的全部頂點的距離，直至檢測到環的存在，此時隊列非空。環被保存在 edgeTo[ ] 中，FindNegativeCycle 會在其中找到它。

 

 

 

 　　7.總結

 　　下表總結了上面的各類最短路徑算法的重要性質。在這些算法中進行選擇的第一個條件是問題所涉及的有向圖的基本性質。它含有負權重的邊嗎？它含有環嗎？它含有負權重的環嗎？除了這些基本性質以外，加權有向圖的特性多種多樣，所以在有多個合適的選擇時就須要經過實驗找出最佳算法。