本文章為轉載，這裡找點哪裡找點湊齊的，這樣可以方便進行了解幾種演算法相同點和不同點

spfa部分轉自：http://blog.csdn.net/maxichu/article/details/45309463

  spfa：適用範圍：給定的圖存在負權邊，這時類似Dijkstra等演算法便沒有了用武之地，而Bellman-Ford演算法的複雜度又過高，SPFA演算法便派上用場了。 我們約定有向加權圖G不存在負權迴路，即最短路徑一定存在。當然，我們可以在執行該演算法前做一次拓撲排序，以判斷是否存在負權迴路，但這不是我們討論的重點。

演算法思想：我們用陣列d記錄每個結點的最短路徑估計值，用鄰接表來儲存圖G。我們採取的方法是動態逼近法：設立一個先進先出的佇列用來儲存待優化的結點，優化時每次取出隊首結點u，並且用u點當前的最短路徑估計值對離開u點所指向的結點v進行鬆弛操作，如果v點的最短路徑估計值有所調整，且v點不在當前的佇列中，就將v點放入隊尾。這樣不斷從佇列中取出結點來進行鬆弛操作，直至佇列空為止

期望的時間複雜度O(ke)， 其中k為所有頂點進隊的平均次數，可以證明k一般小於等於2。

實現方法：

　　建立一個佇列，初始時佇列裡只有起始點，再建立一個表格記錄起始點到所有點的最短路徑（該表格的初始值要賦為極大值，該點到他本身的路徑賦為0）。然後執行鬆弛操作，用佇列裡有的點作為起始點去重新整理到所有點的最短路，如果重新整理成功且被重新整理點不在佇列中則把該點加入到佇列最後。重複執行直到佇列為空。

判斷有無負環：
　　如果某個點進入佇列的次數超過N次則存在負環（SPFA無法處理帶負環的圖）

首先建立起始點a到其餘各點的最短路徑表格

首先源點a入隊，當佇列非空時：
　１、隊首元素（a）出隊，對以a為起始點的所有邊的終點依次進行鬆弛操作（此處有b,c,d三個點），此時路徑表格狀態為：

在鬆弛時三個點的最短路徑估值變小了，而這些點佇列中都沒有出現，這些點
需要入隊，此時，佇列中新入隊了三個結點b,c,d

隊首元素b點出隊，對以b為起始點的所有邊的終點依次進行鬆弛操作（此處只有e點），此時路徑表格狀態為：

在最短路徑表中，e的最短路徑估值也變小了，e在佇列中不存在，因此e也要
入隊，此時佇列中的元素為c，d，e

隊首元素c點出隊，對以c為起始點的所有邊的終點依次進行鬆弛操作（此處有e,f兩個點），此時路徑表格狀態為：

在最短路徑表中，e，f的最短路徑估值變小了，e在佇列中存在，f不存在。因此
e不用入隊了，f要入隊，此時佇列中的元素為d，e，f

 隊首元素d點出隊，對以d為起始點的所有邊的終點依次進行鬆弛操作（此處只有g這個點），此時路徑表格狀態為：

隊首元素為e，f，g。然後e點出對隊，e只指向g，然後此時g的最短路徑估值沒有變小（鬆弛不成功），沒有新結點入隊，佇列中元素為f，g，表格狀態仍然為：

隊首元素f點出隊，對以f為起始點的所有邊的終點依次進行鬆弛操作（此處有d，e，g三個點），此時路徑表格狀態為：

在最短路徑表中，e，g的最短路徑估值又變小，佇列中無e點，e入隊，佇列中存在g這個點，g不用入隊，此時佇列中元素為g，e

隊首元素g點出隊，對以g為起始點的所有邊的終點依次進行鬆弛操作（此處只有b點），此時路徑表格狀態為：

在最短路徑表中，b的最短路徑估值又變小，佇列中無b點，b入隊，此時佇列中元素為e，b
隊首元素e點出隊，對以e為起始點的所有邊的終點依次進行鬆弛操作（此處只有g這個點），此時路徑表格狀態為：

在最短路徑表中，g的最短路徑估值沒變化（鬆弛不成功），此時佇列中元素為b

隊首元素b點出隊，對以b為起始點的所有邊的終點依次進行鬆弛操作（此處只有e這個點），此時路徑表格狀態為：

在最短路徑表中，e的最短路徑估值沒變化（鬆弛不成功），此時佇列為空了

最終a到g的最短路徑為１４。

程式碼；

#include<iostream>  
#include<deque>  
#include<cstdio>  
#include<algorithm>  
using namespace std;  
const int MAXN = 110;  
const int MAXM = 10100;  
const int INF = 0x3f3f3f3f;  
  
struct Edge  
{  
    int from, to, cap, next;  
};  
Edge edge[MAXM];  
int head[MAXN];  
int path[MAXN];  
int inqueue[MAXN];  
int dist[MAXN];  
int viscnt[MAXN];  
int cnt;  
void addedge( int from, int to, int cap )  
{  
    edge[cnt].from = from;  
    edge[cnt].to = to;  
    edge[cnt].cap = cap;  
    edge[cnt].next = head[from];  
    head[from] = cnt++;  
}  
int relax(int u,int v,int c)  
{  
    if (dist[u] + c < dist[v])  
    {  
        dist[v] = dist[u] + c;  
        return 1;  
    }  
    return 0;  
}  
bool SPFA( int src, int n )  
{  
    deque<int> dq;  
    memset( viscnt, 0, sizeof viscnt );  
    memset( inqueue, 0, sizeof inqueue );  
    memset( dist, INF, sizeof dist );  
    memset( path, -1, sizeof path );  
    inqueue[src] = 1;  
    viscnt[src]++;  
    dist[src] = 0;  
    dq.push_back( src );  
    while (!dq.empty())  
    {  
        int u = dq.front();  
        dq.pop_front();  
        inqueue[u] = 0;  
        for(int i = head[u]; i != -1; i = edge[i].next)  
        {  
            int v = edge[i].to;  
            if(dist[u] < INF&&relax( u, v, edge[i].cap ))  
            {  
                path[v] = u;  
                if(!inqueue[v])  
                {  
                    inqueue[v] = 1;  
                    viscnt[v]++;  
                    if(viscnt[v] == n)  return false;  
                    if(!dq.empty() && dist[v] <= dist[dq.front()])  
                        dq.push_front( v );  
                    else  
                        dq.push_back( v );  
                }  
            }  
        }  
    }  
    return true;  
}    
int main()  
{  
    int n,m;  
    while(cin >> n >> m &&n&&m)  
    {  
        memset( head, -1, sizeof head );  
        cnt = 0;  
        for(int i = 1; i <= m; i++)  
        {  
            int a, b, c;  
            cin >> a >> b >> c;  
            addedge( a, b, c );//在a->b新增一條負載為c的邊  
            addedge( b, a, c );  
        }  
        SPFA( 1, n );  
        cout << dist[n] << endl;  
    }  
    return 0;  
}

注意：聽說下面程式碼部分未經過測試

以下轉自：http://www.cnblogs.com/biyeymyhjob/archive/2012/07/31/2615833.html

Dijkstra演算法

1.定義概覽

Dijkstra(迪傑斯特拉)演算法是典型的單源最短路徑演算法，用於計算一個節點到其他所有節點的最短路徑。主要特點是以起始點為中心向外層層擴充套件，直到擴充套件到終點為止。Dijkstra演算法是很有代表性的最短路徑演算法，在很多專業課程中都作為基本內容有詳細的介紹，如資料結構，圖論，運籌學等等。注意該演算法要求圖中不存在負權邊。

問題描述：在無向圖 G=(V,E) 中，假設每條邊 E[i] 的長度為 w[i]，找到由頂點 V0 到其餘各點的最短路徑。（單源最短路徑）

2.演算法描述

1)演算法思想：設G=(V,E)是一個帶權有向圖，把圖中頂點集合V分成兩組，第一組為已求出最短路徑的頂點集合（用S表示，初始時S中只有一個源點，以後每求得一條最短路徑 , 就將加入到集合S中，直到全部頂點都加入到S中，演算法就結束了），第二組為其餘未確定最短路徑的頂點集合（用U表示），按最短路徑長度的遞增次序依次把第二組的頂點加入S中。在加入的過程中，總保持從源點v到S中各頂點的最短路徑長度不大於從源點v到U中任何頂點的最短路徑長度。此外，每個頂點對應一個距離，S中的頂點的距離就是從v到此頂點的最短路徑長度，U中的頂點的距離，是從v到此頂點只包括S中的頂點為中間頂點的當前最短路徑長度。

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.演算法程式碼實現：

const int  MAXINT = 32767;
const int MAXNUM = 10;
int dist[MAXNUM];
int prev[MAXNUM];

int A[MAXUNM][MAXNUM];

void Dijkstra(int v0)
{
  　　bool S[MAXNUM];                                  // 判斷是否已存入該點到S集合中
      int n=MAXNUM;
  　　for(int i=1; i<=n; ++i)
 　　 {
      　　dist[i] = A[v0][i];
      　　S[i] = false;                                // 初始都未用過該點
      　　if(dist[i] == MAXINT)    
            　　prev[i] = -1;
 　　     else 
            　　prev[i] = v0;
   　　}
   　 dist[v0] = 0;
   　 S[v0] = true; 　　
 　　 for(int i=2; i<=n; i++)
 　　 {
       　　int mindist = MAXINT;
       　　int u = v0; 　　                            // 找出當前未使用的點j的dist[j]最小值
      　　 for(int j=1; j<=n; ++j)
      　　    if((!S[j]) && dist[j]<mindist)
      　　    {
         　　       u = j;                             // u儲存當前鄰接點中距離最小的點的號碼 
         　 　      mindist = dist[j];
       　　   }
       　　S[u] = true; 
       　　for(int j=1; j<=n; j++)
       　　    if((!S[j]) && A[u][j]<MAXINT)
       　　    {
           　    　if(dist[u] + A[u][j] < dist[j])     //在通過新加入的u點路徑找到離v0點更短的路徑  
           　    　{
                   　　dist[j] = dist[u] + A[u][j];    //更新dist 
                   　　prev[j] = u;                    //記錄前驅頂點 
            　　    }
        　    　}
   　　}
}

4.演算法例項

先給出一個無向圖

用Dijkstra演算法找出以A為起點的單源最短路徑步驟如下

Floyd演算法

1.定義概覽

Floyd-Warshall演算法（Floyd-Warshall algorithm）是解決任意兩點間的最短路徑的一種演算法，可以正確處理有向圖或負權的最短路徑問題，同時也被用於計算有向圖的傳遞閉包。Floyd-Warshall演算法的時間複雜度為O(N³)，空間複雜度為O(N²)。

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).Floyd演算法過程矩陣的計算----十字交叉法

方法：兩條線，從左上角開始計算一直到右下角 如下所示

給出矩陣，其中矩陣A是鄰接矩陣，而矩陣Path記錄u,v兩點之間最短路徑所必須經過的點

相應計算方法如下：

最後A₃即為所求結果

3.演算法程式碼實現

typedef struct          
{        
    char vertex[VertexNum];                                //頂點表         
    int edges[VertexNum][VertexNum];                       //鄰接矩陣,可看做邊表         
    int n,e;                                               //圖中當前的頂點數和邊數         
}MGraph; 

void Floyd(MGraph g)
{
 　　int A[MAXV][MAXV];
 　　int path[MAXV][MAXV];
 　　int i,j,k,n=g.n;
 　　for(i=0;i<n;i++)
    　　for(j=0;j<n;j++)
    　　{ 　　
             A[i][j]=g.edges[i][j];
         　　 path[i][j]=-1;
     　 }
 　　for(k=0;k<n;k++)
 　　{ 
      　　for(i=0;i<n;i++)
         　　for(j=0;j<n;j++)
             　　if(A[i][j]>(A[i][k]+A[k][j]))
             　　{
                   　　A[i][j]=A[i][k]+A[k][j];
                   　　path[i][j]=k;
              　 } 
    　} 
} 

演算法時間複雜度:O(n³)