從一個頂點到達另一個頂點的成本最小的路徑。
我們採用一個一般性的模型，即加權有向圖。在加權有向圖中，每條有向路徑都有一個與之關聯的路徑權重，它是路徑中的所有邊的權重之和。這種重要的度量方式使得我們能夠將這個問題歸納為 “找到有個頂點到達另一個頂點的權重最小的有向路徑”。
單點最短路徑。給定一幅加權有向圖和一個起點 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.總結
下表總結了上面的各種最短路徑演算法的重要性質。在這些演算法中進行選擇的第一個條件是問題所涉及的有向圖的基本性質。它含有負權重的邊嗎？它含有環嗎？它含有負權重的環嗎？除了這些基本性質之外，加權有向圖的特性多種多樣，因此在有多個合適的選擇時就需要通過實驗找出最佳演算法。
