① 最短路徑演算法
Dijkstra演算法，A*演算法和D*演算法
Dijkstra演算法是典型最短路演算法，用於計算一個節點到其他所有節點的最短路徑。主要特點是以起始點為中心向外層層擴展，直到擴展到終點為止。Dijkstra演算法能得出最短路徑的最優解，但由於它遍歷計算的節點很多，所以效率低。
Dijkstra演算法是很有代表性的最短路演算法，在很多專業課程中都作為基本內容有詳細的介紹，如數據結構，圖論，運籌學等等。
Dijkstra一般的表述通常有兩種方式，一種用永久和臨時標號方式，一種是用OPEN, CLOSE表方式，Drew為了和下面要介紹的 A* 演算法和 D* 演算法表述一致，這里均採用OPEN,CLOSE表的方式。
大概過程：
創建兩個表，OPEN, CLOSE。
OPEN表保存所有已生成而未考察的節點，CLOSED表中記錄已訪問過的節點。
1． 訪問路網中里起始點最近且沒有被檢查過的點，把這個點放入OPEN組中等待檢查。
2． 從OPEN表中找出距起始點最近的點，找出這個點的所有子節點，把這個點放到CLOSE表中。
3． 遍歷考察這個點的子節點。求出這些子節點距起始點的距離值，放子節點到OPEN表中。
4． 重復2，3，步。直到OPEN表為空，或找到目標點。
提高Dijkstra搜索速度的方法很多，常用的有數據結構採用Binary heap的方法，和用Dijkstra從起始點和終點同時搜索的方法。
A*（A-Star)演算法是一種啟發式演算法，是靜態路網中求解最短路最有效的方法。
公式表示為： f(n)=g(n)+h(n),
其中f(n) 是節點n從初始點到目標點的估價函數，
g(n) 是在狀態空間中從初始節點到n節點的實際代價，
h(n)是從n到目標節點最佳路徑的估計代價。
保證找到最短路徑（最優解的）條件，關鍵在於估價函數h(n)的選取：
估價值h(n)<= n到目標節點的距離實際值，這種情況下，搜索的點數多，搜索范圍大，效率低。但能得到最優解。
如果 估價值>實際值, 搜索的點數少，搜索范圍小，效率高，但不能保證得到最優解。
估價值與實際值越接近，估價函數取得就越好。
例如對於幾何路網來說，可以取兩節點間歐幾理德距離（直線距離）做為估價值，即f=g(n)+sqrt((dx-nx)*(dx-nx)+(dy-ny)*(dy-ny))；這樣估價函數f在g值一定的情況下，會或多或少的受估價值h的制約，節點距目標點近，h值小，f值相對就小，能保證最短路的搜索向終點的方向進行。明顯優於Dijstra演算法的毫無無方向的向四周搜索。
conditions of heuristic
Optimistic (must be less than or equal to the real cost)
As close to the real cost as possible
主要搜索過程：
創建兩個表，OPEN表保存所有已生成而未考察的節點，CLOSED表中記錄已訪問過的節點。
遍歷當前節點的各個節點，將n節點放入CLOSE中，取n節點的子節點X,->算X的估價值->
While(OPEN!=NULL)
{
從OPEN表中取估價值f最小的節點n;
if(n節點==目標節點) break;
else
{
if(X in OPEN) 比較兩個X的估價值f //注意是同一個節點的兩個不同路徑的估價值
if( X的估價值小於OPEN表的估價值 )
更新OPEN表中的估價值; //取最小路徑的估價值
if(X in CLOSE) 比較兩個X的估價值 //注意是同一個節點的兩個不同路徑的估價值
if( X的估價值小於CLOSE表的估價值 )
更新CLOSE表中的估價值; 把X節點放入OPEN //取最小路徑的估價值
if(X not in both)
求X的估價值;
並將X插入OPEN表中; //還沒有排序
}
將n節點插入CLOSE表中;
按照估價值將OPEN表中的節點排序; //實際上是比較OPEN表內節點f的大小，從最小路徑的節點向下進行。
}
A*演算法和Dijistra演算法的區別在於有無估價值，Dijistra演算法相當於A*演算法中估價值為0的情況。
動態路網，最短路演算法 D*A* 在靜態路網中非常有效（very efficient for static worlds），但不適於在動態路網，環境如權重等不斷變化的動態環境下。
D*是動態A*（D-Star,Dynamic A*） 卡內及梅隆機器人中心的Stentz在1994和1995年兩篇文章提出，主要用於機器人探路。是火星探測器採用的尋路演算法。
主要方法：
1.先用Dijstra演算法從目標節點G向起始節點搜索。儲存路網中目標點到各個節點的最短路和該位置到目標點的實際值h,k（k為所有變化h之中最小的值,當前為k=h。每個節點包含上一節點到目標點的最短路信息1(2),2(5),5(4)，4（7）。則1到4的最短路為1-2-5-4。
原OPEN和CLOSE中節點信息保存。
2.機器人沿最短路開始移動，在移動的下一節點沒有變化時，無需計算，利用上一步Dijstra計算出的最短路信息從出發點向後追述即可，當在Y點探測到下一節點X狀態發生改變，如堵塞。機器人首先調整自己在當前位置Y到目標點G的實際值h(Y)，h(Y)=X到Y的新權值c(X,Y)+X的原實際值h(X).X為下一節點(到目標點方向Y->X->G），Y是當前點。k值取h值變化前後的最小。
3.用A*或其它演算法計算，這里假設用A*演算法,遍歷Y的子節點，點放入CLOSE,調整Y的子節點a的h值，h(a)=h(Y)+Y到子節點a的權重C(Y,a),比較a點是否存在於OPEN和CLOSE中，方法如下：
while()
{
從OPEN表中取k值最小的節點Y;
遍歷Y的子節點a,計算a的h值 h(a)=h(Y)+Y到子節點a的權重C(Y,a)
{
if(a in OPEN) 比較兩個a的h值
if( a的h值小於OPEN表a的h值 )
{ 更新OPEN表中a的h值;k值取最小的h值
有未受影響的最短路經存在
break;
}
if(a in CLOSE) 比較兩個a的h值 //注意是同一個節點的兩個不同路徑的估價值
if( a的h值小於CLOSE表的h值 )
{
更新CLOSE表中a的h值; k值取最小的h值;將a節點放入OPEN表
有未受影響的最短路經存在
break;
}
if(a not in both)
將a插入OPEN表中; //還沒有排序
}
放Y到CLOSE表；
OPEN表比較k值大小進行排序；
}
機器人利用第一步Dijstra計算出的最短路信息從a點到目標點的最短路經進行。
D*演算法在動態環境中尋路非常有效，向目標點移動中，只檢查最短路徑上下一節點或臨近節點的變化情況，如機器人尋路等情況。對於距離遠的最短路徑上發生的變化，則感覺不太適用。
② 尋找最短路徑的匯編語言實現源代碼是什麼(用Dijkstra 演算法)
Dijkstra演算法Dijkstra演算法是典型的最短路徑演算法，用於計算一個節點的最短路徑中的所有其他節點。其主要特點是出發點為中心向外層層擴展，直到擴展到結束日期。 Dijkstra最短路徑演算法能得出最佳的解決方案，但許多節點，它遍歷計算，這樣的效率是低的。最短路徑演算法的
Dijkstra演算法是非常有代表性的許多專業課程的基本內容進行了詳細的介紹，如數據結構，圖論，運籌學，等等。
Dijkstra演算法的一般性發言一般有兩種方式，永久和臨時的標簽，開啟，關閉表的方式之一，德魯表示，為了引進和下面的A *演算法和D *演算法一致，這里是開放的，關閉表。
貪婪的方法，演算法策略
大概過程如下：
創建兩個表，打開，關閉。
OPEN表保存沒有調查之前已產生的所有節點，CLOSED表中記錄已訪問過的節點。
1。的道路網路的出發點和等待在公開組的檢查沒有檢查點，此點。
2。打開表，以找出從起點最近的點，以確定所有的子節點，這一點，這點上關閉表。
3。遍歷訪問這個點的子節點。獲得這些子節點從子節點到OPEN表的放電的開始點的距離的值。
4。重復步驟2和步驟3，直到OPEN表為空，或找到目標點。
[編輯本段]演算法是
包括的文件
定義MAXNUM 765432100的
使用命名空間std;
ifstream的散熱片（Dijkstra演算法。在「）;
ofstream這樣的FOUT（」Dijkstra.out「）;
詮釋地圖[501] [501];
布爾is_arrived [501];
詮釋區[501] [501]，堆棧[501];
整數P，Q，K，路徑，源代碼，頂點，溫度，SetCard
詮釋FindMin（）
{
詮釋P，溫度= 0，MINM = MAXNUM;
（P = 1，P <=頂點，P + +）
（（區[P] MINM）&&（！is_arrived [P] ））
{
MINM區[P]。
溫度= P;
}
收益溫度;
}
：（ ）
{
的memset（is_arrived，0，大小（is_arrived））;
鰭>>源代碼>>頂點;
（P = 1，P <=頂點，P + +）
（Q = 1，Q =頂點，Q + +）
{
鰭>>地圖[P] [Q];
（圖[ P] [Q] == 0）地圖[P] [Q] = MAXNUM;
}
為（P = 1，P <=頂點，P + +）
{ />區[P] =地圖[來源] [P];
（區[P]！= MAXNUM）
[P] =源;
其他
[P] = P;
}
is_arrived [來源] = TRUE;
SetCard = 1;
{
溫度= FindMin（）;
（Temp! = 0）
{
SetCard SetCard +1;
is_arrived [溫度] = TRUE;
（P = 1，P <=頂點，P + +）
（（區[P]>區[溫度] +地圖[溫度] [P]）&&（！is_arrived [P]））
{
區[P] =區[溫度] +地圖[溫度] [P]
[P] =溫度;
}
}
其他
突破; BR />}
（SetCard! =頂點）;
（P = 1，P <=頂點，P + +）
（p! =源）
{
FOUT <<「======================== \ n」;
FOUT <<「來源：」<; <資料來源<<「\ n目標：」「P <<'\ n';
（區[P] == MAXNUM）
{
FOUT <<」距離：「< 「無限\ n」;
FOUT <<「路徑：沒辦法！」;
}
其他
{
FOUT「距離」：「<<區[P] <<'\ n';
K = 1;
路徑= P;
同時（從[路徑]！=路徑）
{
棧[K] =路徑;
路徑=從[路徑];
K = K +1;
}
FOUT <<「路徑：」<（Q = K-1，Q = 1，Q - ）
FOUT「 - >」<<棧[問];
}
FOUT <<「\ ?======================== \ n \ n「;}
fin.close（）;
fout.close（）;
返回0;
}
樣品輸入
2
7
00 20 50 30 00 00 00
20 00 25 00 00 70 00
50 25 00 40 25 50 00
30 00 40 0??0 55 00 00
00 00 25 55 00 10 00
00 70 50 00 10 00 00
00 00 00 00 00 00 00
樣本輸出
========================
來源：2
目標：1
距離：20
路徑：2 - > 1
==================== ====
========================
來源：
目標：3
距離：25
路徑：2 - > 3 ========================
===== ===================
來源：
目標：4
距離：50
路徑：2 - > 1 - > ======================== 4
============== =========
來源：
目標：5
距離：50
路徑：2 - > 3 - > 5
== ======================
========================
來源：
目標：6
距離：60
路徑：2 - > 3 - > 5 - > 6
========= ===============
========================
來源：2
目標：7
距離：無限
路徑：沒辦法！
========================
示常式序和相關子程序如下：
無效的Dijkstra（INT N，INT [ ]距離的int [] iPath標）
{
詮釋最短距離，U
INT I，J;
/ /從n個頂點的鄰接矩陣的副本可以擺脫行了，是復制前n行的距離[]
（i = 0;我VerNum，我+ +）
{
距離=圓弧[N];
訪問= 0;
} / / n個結點訪問，因為n個頂點的出發點是
訪問[N] = 1;
/ /找到的頂點其他頂點的路線，並且它不是頂點n的開頭，沒有先前旅遊。
/ /相當於u點，這一點是沒有的出發點N（i = 0; I <VerNum，我+ +）
{
U = 0
最短距離=否;
為（J = 0; <VerNum; + +）
（訪問[J] == 0 &&（距離[J]最短距離））
{
最短距離=距離[J];
ü= J;
}
/ /例如P1871圖G6距離=無，無，無，30,100]第一次看的是V2，U = 2
/ /找到結束，的MinDis意味著它無法連接，然後返回。這種情況是相似的V5。
（最短距離==否）返回;
/ /建立一個u個頂點將被用於頂點u，相當於弧[V，U +弧U，W] 。
訪問[U] = 1;
/ /找到一個U頂點到所有其他頂點最小的路徑實際上是在尋找弧] [U，J，J值在[0， VerNum]。
/ /如果是圓弧，U [I] +凱旋門[U，J] ARC [I，J]，ARC [I，J] =弧[I，U] +凱旋門[U J] <弧[I，J]
/ /的做法，因為距離[]是期望的結果，起始點確定的情況下，那就是：
/ /如果（距離[U] +圓弧[U，J）<=距離[J]：
/ /距離[J]距離[U] + [U，J弧];
/ /保存iPath標[] u點數量;
/ /同樣，設置訪問量：新發現的路由[J] = 0，經過尋找另一條道路，這條道路可能不利用。 V3
（J = 0; <VerNum; + +）
（訪問[J] == 0 &&弧U，J] <&& U！= J） /> {
（（距離[U] +圓弧[U，J）<=距離[J]）
{
距離[J]距離[U] +弧[ U，J];
訪問[J] = 0;
iPath標[J] = U;
}
}
}
} / /輔助功能
無效的Prim（），
{
INT I，M，N = 0;
為（i = 0;我VerNum;我+ +）
{
訪問= 0;
T =新的TreeNode（）;
T.Text = V;
}
訪問[N] + +;
listBox1.Items。添加（V [N]）;
（參觀（）> 0）
{
（（M = MinAdjNode（N））！= -1）
{ BR /> T [N]。 Nodes.Add（T [M]）;
N = M;
訪問[N] + +;
}
其他
{
?= MinNode（0）;
（N> 0）T [旻]。 Nodes.Add（T [敏]）;
訪問[N] + +;
}
listBox1.Items.Add（V [N]）;
} treeView1.Nodes.Add（T [0]）;
}
的無效TopoSort（）
{
INT I，N;
listBox1.Items.Clear（ ）;
棧S =新的堆棧（）;
為（i = 0;我VerNum，我+ +）
訪問= 0;
為（= VerNum- 1> = 0; I - ）
（入度（I）== 0）
{
S.Push（I）;
訪問+ +; ...... />}
而（S.Count！= 0）
{
N =（INT）S.Pop（）;
listBox1.Items.Add（V [N] ）;
CLEARLINK（N）;
為（i = VerNum-1> = 0; I - ）
（分== 0 &&入度（I）== 0）
{
S.Push（I）;
訪問+ +;
}
}
}
無效AOETrave（INT N，樹節點TR，W）
{
INT I，W0;
（出度（N）== 0）返回;
（i = 0; <VerNum; + +）
（（W0 =圓弧[N，I]）！= 0）
{
listBox1.Items.Add（V +「\ t」+（W + W0）的ToString（）+「\ t」+ i.ToString（）+「\ t」+ n.ToString（））;
TreeNode的T1 =新的TreeNode（）;
T1.Text = V + 「W =」+（W + W0）。的ToString（）+「]」;
TR.Nodes.Add（T1）;
AOETrave（I，T1，W + W0）;
}
}
無效AOE（）
{
INT I，W = 0，M = 1;
TreeNode的T1 =新的TreeNode（）;
為（i = 0; <VerNum;我+ +）
{
訪問= 0;
}
T1.Text = V [0];
listBox1.Items.Add（「父母符號顯示生成樹：「）;
listBox1.Items.Add（」V \ TW \工業貿易署\ TPID「）;
為（i = 0;我VerNum，我+ +）
{
（（W =弧[0，I]）！= 0）
{
listBox1.Items.Add（V +「\ t」+ w.ToString（）+「\ T「+ i.ToString（）+」\ T0「）;
TreeNode的T2 =新的TreeNode（）;
T2.Text = V +」W =「+ w.ToString（）+」 「;
AOETrave（I，T2，W）;
listBox1.Items.Add（」\ t \ t樹「+ m.ToString
T1.Nodes.Add（ T2），（））;
米+ +;
}
}
treeView1.Nodes.Clear（）;
treeView1.Nodes.Add（T1）;
}
IsZero（）
{
我;
為（i = 0;我VerNum，我+ +）
（LineIsZero （一）> = 0）返回;
返回-1;
}
詮釋LineIsZero（N）
{
我
（i = 0; <VerNum;我+ +）
（電弧[N，I] = 0）返回;
返回-1;}
：無效DepthTraverse（）
{
INT I，M;
（i = 0; <VerNum，我+ +）
{
訪問= 0; BR /> T =新的TreeNode（）;
T.Text = V
R = 0;
}
而（（M = IsZero（））> = 0）
{
（訪問[M] == 0）
{
listBox1.Items.Add（V [M]）;
R [M] = 1 ;}
訪問[M] + +;
DTrave（M）;
}
為（i = 0; {
（R == 1）
treeView1.Nodes.Add（T）;
}
}
無效DTrave（N） /> {
我;
（LineIsZero（N）<0）返回;
為（i = VerNum-1> = 0; I - ）
（弧[N] = 0）
{
弧[N，I] = 0;
弧[I，N] = 0;
（訪問= = 0）
{
listBox1.Items.Add（V）;
T [N]。 Nodes.Add（T）;
R = 0;
}
訪問+ +;
DTrave（I）;
}
} ：無效BreadthTraverse（）
{
INT I，M;
（i = 0; <VerNum，我+ +）
{
訪問= 0;
T =新的TreeNode（）;
T.Text = V;
R = 0;
}
而（（M = IsZero（））> = 0 ）
{
（訪問[M] == 0）
{
listBox1.Items。添加（V [M]）;
R [M] = 1;
}
訪問[M] + +;
BTrave（M）;
} BR />（i = 0;我VerNum，我+ +）
{
（R == 1）
treeView1.Nodes.Add（T）;
}
}
無效BTrave（N）
{
我
隊列Q =新的Queue（）;
Q.Enqueue（N）
而（Q.Count！= 0）
{
為（i = 0;我VerNum，我+ +）
{
（電弧N，I] = 0）
{
弧[N，I] = 0;
弧[N] = 0;
（訪問== 0）
{
listBox1.Items.Add（V）;
T [N]。 Nodes.Add（T）;
直徑= 0;
}
訪問+ +;
Q.Enqueue（I）;
}
} BR /> N =（int）的Q.Dequeue（）;
}
}
詮釋MinNode（VN）
{
INT I，J，N，米，最小=否;
N = -1，M = -1;
為（i = VN我VerNum，我+ +）
中for（j = 0; J < VerNum; + +）
（電弧[I，J] = &&弧[I，J]閔&&分== 0 &&訪問[J] == 1）
{ BR />最小值=弧[I，J]; N = I，M = J;
}
敏=旻= M
返回n;
} BR />詮釋MinAdjNode（N）
{
我，敏，米;
最小值=否，M = -1;
（i = 0; I < VerNum，我+ +）
（電弧[N，I] =沒有訪問&& == 0 &&最小弧[N，I] &&訪問[N] == 1）{BR /> BR />最小值=弧[N，I]，M = I;}
返回米;
}
INT訪問（）
{
INT I，S = 0;
為（i = 0; <VerNum，我+ +）
（訪問== 0）+ +;
返回s;
>}
[編輯本段] Dijkstra演算法的Pascal實現：
程序Dijkstra的;
VAR
答：ARRAY [1 .. 100,1 .. 100的整數;
標志：數組[1] .. 100]布爾值;
W，X，N，I，J，分，明尼蘇達州：整數;
開始
readln（N）;
我：= 1到n
開始
對於j = 1到n
讀（A）;
readln;
結束;
fillchar（標志中，sizeof（標志），假）;
標志[1]：= TRUE;
明尼蘇達州：= 1;
為：= 2到n
開始
分： 32767;
W：=明尼蘇達州
我：= 1到n做
（W >）和（[W，I] <MIN），然後
開始
分：= [];
明尼蘇達州：= I;
結束;
標志[明尼蘇達州]：= TRUE;
J： 1到n做
（J >明尼蘇達州）和（A [1，明尼蘇達州] + A [明尼蘇達州，J]，A [1，J）和（標志[J] = FALSE），那麼 BR /> A [1，J] = [1，明尼蘇達州] + A [明尼蘇達州，J];
結束;
我：= 1到n做
寫（ [1]）;
年底。
③ 計算機網路的最短路徑演算法有哪些對應哪些協議
用於解決最短路徑問題的演算法被稱做「最短路徑演算法」，有時被簡稱作「路徑演算法」。最常用的路徑演算法有：
Dijkstra演算法、A*演算法、SPFA演算法、Bellman-Ford演算法和Floyd-Warshall演算法，本文主要介紹其中的三種。
最短路徑問題是圖論研究中的一個經典演算法問題，旨在尋找圖（由結點和路徑組成的）中兩結點之間的最短路徑。
演算法具體的形式包括：
確定起點的最短路徑問題：即已知起始結點，求最短路徑的問題。
確定終點的最短路徑問題：與確定起點的問題相反，該問題是已知終結結點，求最短路徑的問題。在無向圖中該問題與確定起點的問題完全等同，在有向圖中該問題等同於把所有路徑方向反轉的確定起點的問題。
確定起點終點的最短路徑問題：即已知起點和終點，求兩結點之間的最短路徑。
全局最短路徑問題：求圖中所有的最短路徑。
Floyd
求多源、無負權邊的最短路。用矩陣記錄圖。時效性較差，時間復雜度O(V^3)。
Floyd-Warshall演算法（Floyd-Warshall algorithm）是解決任意兩點間的最短路徑的一種演算法，可以正確處理有向圖或負權的最短路徑問題。
Floyd-Warshall演算法的時間復雜度為O(N^3)，空間復雜度為O(N^2)。
Floyd-Warshall的原理是動態規劃：
設Di,j,k為從i到j的只以(1..k)集合中的節點為中間節點的最短路徑的長度。
若最短路徑經過點k，則Di,j,k = Di,k,k-1 + Dk,j,k-1；
若最短路徑不經過點k，則Di,j,k = Di,j,k-1。
因此，Di,j,k = min(Di,k,k-1 + Dk,j,k-1 , Di,j,k-1)。
在實際演算法中，為了節約空間，可以直接在原來空間上進行迭代，這樣空間可降至二維。
Floyd-Warshall演算法的描述如下：
for k ← 1 to n do
for i ← 1 to n do
for j ← 1 to n do
if (Di,k + Dk,j < Di,j) then
Di,j ← Di,k + Dk,j;
其中Di,j表示由點i到點j的代價，當Di,j為 ∞ 表示兩點之間沒有任何連接。
Dijkstra
求單源、無負權的最短路。時效性較好，時間復雜度為O（V*V+E）,可以用優先隊列進行優化，優化後時間復雜度變為0（v*lgn）。
源點可達的話，O（V*lgV+E*lgV）=>O（E*lgV）。
當是稀疏圖的情況時，此時E=V*V/lgV，所以演算法的時間復雜度可為O（V^2） 。可以用優先隊列進行優化，優化後時間復雜度變為0（v*lgn）。
Bellman-Ford
求單源最短路，可以判斷有無負權迴路（若有，則不存在最短路），時效性較好，時間復雜度O（VE）。
Bellman-Ford演算法是求解單源最短路徑問題的一種演算法。
單源點的最短路徑問題是指：給定一個加權有向圖G和源點s，對於圖G中的任意一點v，求從s到v的最短路徑。
與Dijkstra演算法不同的是，在Bellman-Ford演算法中，邊的權值可以為負數。設想從我們可以從圖中找到一個環
路（即從v出發，經過若干個點之後又回到v）且這個環路中所有邊的權值之和為負。那麼通過這個環路，環路中任意兩點的最短路徑就可以無窮小下去。如果不處理這個負環路，程序就會永遠運行下去。 而Bellman-Ford演算法具有分辨這種負環路的能力。
SPFA
是Bellman-Ford的隊列優化，時效性相對好，時間復雜度O（kE）。（k< 與Bellman-ford演算法類似，SPFA演算法採用一系列的鬆弛操作以得到從某一個節點出發到達圖中其它所有節點的最短路徑。所不同的是，SPFA演算法通過維護一個隊列，使得一個節點的當前最短路徑被更新之後沒有必要立刻去更新其他的節點，從而大大減少了重復的操作次數。
SPFA演算法可以用於存在負數邊權的圖，這與dijkstra演算法是不同的。
與Dijkstra演算法與Bellman-ford演算法都不同，SPFA的演算法時間效率是不穩定的，即它對於不同的圖所需要的時間有很大的差別。
在最好情形下，每一個節點都只入隊一次，則演算法實際上變為廣度優先遍歷，其時間復雜度僅為O(E)。另一方面，存在這樣的例子，使得每一個節點都被入隊(V-1)次，此時演算法退化為Bellman-ford演算法，其時間復雜度為O(VE)。
SPFA演算法在負邊權圖上可以完全取代Bellman-ford演算法，另外在稀疏圖中也表現良好。但是在非負邊權圖中，為了避免最壞情況的出現，通常使用效率更加穩定的Dijkstra演算法，以及它的使用堆優化的版本。通常的SPFA。