最短路演算法詳解（Dijkstra/Floyd/SPFA/A*演算法）
最短路徑
在一個無權的圖中，若從一個頂點到另一個頂點存在著一條路徑，則稱該路徑長度為該路徑上所經過的邊的數目，它等於該路徑上的頂點數減1。由於從一個頂點到另一個頂點可能存在著多條路徑，每條路徑上所經過的邊數可能不同，即路徑長度不同，把路徑長度最短（即經過的邊數最少）的那條路徑叫作最短路徑或者最短距離。
對於帶權的圖，考慮路徑上各邊的權值，則通常把一條路徑上所經邊的權值之和定義為該路徑的路徑長度或帶權路徑長度。從源點到終點可能不止一條路徑，把帶權路徑長度最短的那條路徑稱為最短路徑，其路徑長度（權值之和）稱為最短路徑長度或最短距離。
一、Dijkstra演算法
1.定義概覽
Dijkstra(迪傑斯特拉)演算法是典型的單源最短路徑演算法
問題描述：在無向圖 G=(V,E) 中，假設每條邊 E[i] 的長度為 w[i]，找到由頂點 V0 到其餘各點的最短路徑。（單源最短路徑）
2.演算法描述
1)演算法思想：設G=(V,E)是一個帶權有向圖，把圖中頂點集合V分成兩組，第一組為已求出最短路徑的頂點集合（用S表示，初始時S中只有一個源點，以後每求得一條最短路徑 , 就將加入到集合S中，直到全部頂點都加入到S中，演算法就結束了），第二組為其餘未確定最短路徑的頂點集合（用U表示），
2)演算法步驟：
a.初始時，S只包含源點，即S＝{v}，v的距離為0。U包含除v外的其他頂點，即:U={其餘頂點}，若v與U中頂點u有邊，則<u,v>正常有權值，若u不是v的出邊鄰接點，則<u,v>權值為∞。
b.從U中選取一個距離v最小的頂點k，把k，加入S中（該選定的距離就是v到k的最短路徑長度）。
c.以k為新考慮的中間點，修改U中各頂點的距離；若從源點v到頂點u的距離（經過頂點k）比原來距離（不經過頂點k）短，則修改頂點u的距離值，修改後的距離值的頂點k的距離加上邊上的權。
d.重複步驟b和c直到所有頂點都包含在S中。
執行動畫：
3.演算法例項：
用Dijkstra演算法找出以A為起點的單源最短路徑步驟如下
4.侷限性：Dijkstra沒辦法解決負邊權的最短路徑，如圖
（因為過程中先選擇v3，v3被標記為已知，今後不再更新）
5.演算法實現：
普通的鄰接表用vis作為上面標記的known，dis記錄最短距離（記得初始化為一個很大的數）。
void dijkstra(int s)
{
memset(vis,0,sizeof(vis));
int cur=s;
dis[cur]=0;
vis[cur]=1;
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
if(!vis[j] && dis[cur] + map[cur][j] < dis[j]) //未被標記且比已知的短，可更新
dis[j]=dis[cur] + map[cur][j] ;
int mini=INF;
for(int j=0;j<n;j++)
if(!vis[j] && dis[j] < mini) //選擇下一次到已知頂點最短的點。
mini=dis[cur=j];
vis[cur]=true;
}
} struct point
{
int val,id;
point(int id,int val):id(id),val(val){}
bool operator <(const point &x)const{
return val>x.val;
}
};
void dijkstra(int s)
{
memset(vis,0,sizeof(vis));
for(int i=0;i<n;i++)
dis[i]=INF;
priority_queue<point> q;
q.push(point(s,0));
dis[s]=0;
while(!q.empty())
{
int cur=q.top().id;
q.pop();
if(vis[cur]) continue;
vis[cur]=true;
for(int i=head[cur];i!=-1;i=e[i].next)
{
int id=e[i].to;
if(!vis[id] && dis[cur]+e[i].val < dis[id])
{
dis[id]=dis[cur]+e[i].val;
q.push(point(id,dis[id]));
}
}
}
} 二、Floyd演算法
1.定義概覽
Floyd-Warshall演算法（Floyd-Warshall algorithm）是解決任意兩點間的最短路徑的一種演算法，可以正確處理有向圖或負權的最短路徑問題，
同時也被用於計算有向圖的傳遞閉包。Floyd-Warshall演算法的時間複雜度為O(N3)，空間複雜度為O(N2)。
2.演算法描述
1)演算法思想原理：
Floyd演算法是一個經典的動態規劃演算法。用通俗的語言來描述的話，首先我們的目標是尋找從點i到點j的最短路徑。從動態規劃的角度看問題，
我們需要為這個目標重新做一個詮釋（這個詮釋正是動態規劃最富創造力的精華所在）
從任意節點i到任意節點j的最短路徑不外乎2種可能，1是直接從i到j，2是從i經過若干個節點k到j。所以，我們假設Dis(i,j)為節點u到節點v的
最短路徑的距離，對於每一個節點k，我們檢查Dis(i,k) + Dis(k,j) < Dis(i,j)是否成立，如果成立，證明從i到k再到j的路徑比i直接到j的路徑短，
我們便設定Dis(i,j) = Dis(i,k) + Dis(k,j)，這樣一來，當我們遍歷完所有節點k，Dis(i,j)中記錄的便是i到j的最短路徑的距離。
2).演算法描述：
a.從任意一條單邊路徑開始。所有兩點之間的距離是邊的權，如果兩點之間沒有邊相連，則權為無窮大。
b.對於每一對頂點 u 和 v，看看是否存在一個頂點 w 使得從 u 到 w 再到 v 比己知的路徑更短。如果是更新它。
3.演算法例項：
鄰接矩陣：
第一步:以定點0作為鬆弛的點，考慮a[i][j]表示定點i到頂點j經由頂點0的最短路徑長度，經過比較，沒有任何路徑得到修改，因此有： 
第二步：以定點1作為鬆弛的點，考慮a[i][j]表示定點i到頂點j經由頂點1的最短路徑長度，經過比較，頂點0到頂點1由原來的沒有路徑變為0—1—2的路徑，其長度為9；因此有： 
第三步：以定點2作為鬆弛的點，考慮a[i][j]表示定點i到頂點j經由頂點2的最短路徑長度，經過比較，頂點1到頂點0由原來的沒有路徑變為1—2—0的路徑，其長度為7；
頂點3到頂點0由原來的沒有路徑變為3—2—0的路徑，其長度為4
頂點3到頂點3由原來的沒有路徑變為3—2—1的路徑，其長度為4因此有： 
第四步：以定點3作為鬆弛的點，考慮a[i][j]表示定點i到頂點j經由頂點3的最短路徑長度，經過比較，頂點0到頂點2由原來的路徑長度為9，路徑為 0—1—2，變為0—3—2，其長度為8；
頂點1到頂點0由原來的路徑長度為7，路徑為1—2—0，變為1—3—2—0，其長度為6；
頂點1到頂點2由原來的路徑長度為4，路徑為1—2 ，變為1—3—2 ，其長度為3；
4.演算法實現：
void floyd()
{
for(int k=0;k<n;k++)
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
} 三、SPFA（bellman-ford）
SPFA是bellman-ford的改進演算法(佇列實現），效率也更高，故直接介紹SPFA。 相比於Dijkstra，SPFA可以計算帶負環的迴路。 鄰接表的複雜度為：O(kE)E為邊數，k一般為2或31.原理過程：
bellman-ford演算法的基本思想是，對圖中除了源頂點s外的任意頂點u，依次構造從s到u的最短路徑長度序列dist[u],dis2[u]……dis(n-1)[u]，其中n是 圖G的頂點數，dis1[u]是從s到u的只經過1條邊的最短路徑長度，dis2[u]是從s到u的最多經過G中2條邊的最短路徑長度……當圖G中沒有從源可達的 負權圖時，從s到u的最短路徑上最多有n-1條邊。因此，dist(n-1)[u]就是從s到u的最短路徑長度，顯然，若從源s到u的邊長為e(s,u)，則dis1[u]=e(s,u).對於k>1，dis（k)[u]滿足如下遞迴式， dis(k)[u]=min{dis(k-1)[v]+e(v,u)}.bellman-ford最短路徑就是按照這個遞迴式計算最短路的。
SPFA的實現如下：用陣列dis記錄更新後的狀態，cnt記錄更新的次數，佇列q記錄更新過的頂點，演算法依次從q中取出待更新的頂點v, 按照dis(k)[u]的遞迴式計算。在計算過程中，一旦發現頂點K有cnt[k]>n，說明有一個從頂點K出發的負權圈，此時沒有最短路，應終止演算法。 否則，佇列為空的時候，演算法得到G的各頂點的最短路徑長度。
2.程式碼實現：
void SPFA(int s)
{
for(int i=0;i<n;i++)
dis[i]=INF;
bool vis[MAXN]={0};
vis[s]=true;
dis[s]=0;
queue<int> q;
q.push(s);
while(!q.empty())
{
int cur=q.front();
q.pop();
vis[cur]=false;
for(int i=0;i<n;i++)
{
if(dis[cur] + map[cur][i] < dis[i])
{
dis[i]=dis[cur] + map[cur][i];
if(!vis[i])
{
q.push(i);
vis[i]=true;
}
}
}
}
} 對負圈的判斷 code :
bool spfa()
{
for(int i=0;i<=n;i++)
dis[i]=INF;
bool vis[MAXN]={0};
int cnt[MAXN]={0};
queue<int> q;
dis[0]=0;
vis[0]=true;
cnt[0]=1;
q.push(0);
while(!q.empty())
{
int cur=q.front();
q.pop();
vis[cur]=false;
for(int i=head[cur];i!=-1;i=e[i].next)
{
int id=e[i].to;
if(dis[cur] + e[i].val > dis[id])
{
dis[id]=dis[cur]+e[i].val;
if(!vis[id])
{
cnt[id]++;
if(cnt[cur] > n)
return false;
vis[id]=true;
q.push(id);
}
}
}
}
return true;
}3.優化
SLF（Small Label First）是指在入隊時如果當前點的dist值小於隊首， 則插入到隊首， 否則插入到隊尾。 LLL不太常用，我也沒研究。4.應用：
眼見的同學應該發現了，上面的差分約束四個字，是的SPFA可以很好的實現差分約束系統。四 、A*搜尋演算法
A*搜尋演算法，俗稱A星演算法。這是一種在圖平面上，有多個節點的路徑，求出最低通過成本的演算法。常用於遊戲中的NPC的移動計算，或線上遊戲的BOT的移動計算上。該演算法像Dijkstra演算法一樣，可以找到一條最短路徑；也像BFS一樣，進行啟發式的搜尋。A*演算法最核心的部分，就在於它的一個估值函式的設計上：f(n)=g(n)+h(n)。其中，g(n)表示從起始點到任一點n的實際距離，h(n)表示任意頂點n到目標頂點的估算距離，f(n)是每個可能試探點的估值。這個估值函式遵循以下特性：
•如果h(n)為0，只需求出g(n)，即求出起點到任意頂點n的最短路徑，則轉化為單源最短路徑問題，即Dijkstra演算法；
•如果h(n)<=“n到目標的實際距離”，則一定可以求出最優解。而且h(n)越小，需要計算的節點越多，演算法效率越低。
我們可以這樣來描述：從出發點(StartPoint,縮寫成sp)到終點(EndPoint，縮寫成ep)的最短距離是一定的，於是我們可以寫一個估值函式來估計出發點到終點的最短距離。如果程式嘗試著從出發點沿著某條線路移動到了路徑上的另一個點（Otherpoint,縮寫成op），那麼我們認為這個方案所得到的從sp到ep間的估計距離為：從sp到op實際已走的距離加上估計函式估出的從op到ep的距離。如此，無論我們的程式搜尋展開到哪一步，都會得到一個估計值，每一次決策後，將評估值和等待處理的方案一起排序，然後挑出待處理的各個方案中最有可能是最短路線的一部分的方案展開到下一步, 一直迴圈直到物件移動到目的地，或所有方案都嘗試過，卻沒有找到一條通向目的地的路徑則結束。
A*搜尋演算法的圖解過程請看：http://blog.vckbase.com/panic/archive/2005/03/20/3778.html