相信大家應該對最短路徑演算法很感興趣吧！不感興趣也沒關係，我們一起來看看下面的例子。最短路徑應該是在眾多演算法中。最常用的一類演算法。為什麼這樣說呢？？
        例如：
        1.乘汽車旅行的人總希望找出到目的地的儘可能的短的行程。如果有一張地圖並在圖上標出每對十字路口之間的距離，如何找出這一最短行程？
        2.某省自從實行了很多年的暢通工程計劃後，終於修建了很多路。不過路多了也不好，每次要從一個城鎮到另一個城鎮時，都有許多種道路方案可以選擇，而某些方案要比另一些方案行走的距離要短很多。這讓行人很困擾。 現在，已知起點和終點，請你計算出要從起點到終點，最短需要行走多少距離。
        那麼如果想要求解這些問題，那麼這裡就會用到最短路徑。

    一：Floyd演算法：

        Floyd演算法是一種求任意點到任意點的最短距離。可以求邊權為負值，有向圖、無向圖等的最短路徑。但是邊權可以有負權值的邊，但不能有包含負權值邊組成的迴路，不然算出來的就不是正確答案！！這個演算法效率很低可以說是暴力。但是這種暴力是帶著動態規劃的暴力！！
        那麼為什麼邊權可以為負值，但是卻不能有邊權和為負值的迴路呢？？這是一個值得深思的問題。
        問得好，這個問題是一個好問題。但是呢？我先把問題放在這！看過程式碼後我在給大家一組資料就可知道！！！

/*
floyd演算法
*/

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define Inf 1<<29

int mp[100][100];
int n,m;
int main(){
    while(~scanf("%d%d",&n,&m)){//代表有n個節點  m 條權值邊
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if
 
(i!=j){//初始化預設距離表示i節點到j節點的距離。節點相同距離為0
                    mp[i][j]=Inf;
                }else{
                    mp[i][j]=0;
                }
            }
        }
        int a,b,c;
        for(int i=1;i<=m;i++){
            scanf("%d%d%d",&a,&b,&c);
            mp[a][b]=c;
           // mp[b][a]=c;//寫上這個就是無向圖
 

        }
        for(int k=1;k<=n;k++){//主要程式碼實現區，可以模擬一下。關鍵是模擬，然後自己再想為什麼。。
            for(int i=1;i<=n;i++){
                for(int j=1;j<=n;j++){
                    if(i!=j&&j!=k){
                        mp[i][j]=min(mp[i][j],mp[i][k]+mp[k][j]);
                    }
                }
            }
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){//在這裡輸出任意點到任意點的距離
                printf("dis %d %d = %d\n",i,j,mp[i][j]);
            }
        }
    }
    return 0;
}

   模擬完後，我就要告訴你這個演算法的特點是什麼和該注意什麼？這個演算法的時間複查度是o(n^3) 是很大的稍微不注意就會超時。當然除了水題。。。它的目的是算任意節點到任意節點的距離，上面也提到過了。
        這裡最需要注意的就是為什麼這個演算法能求出含有負節點卻不能算出含有負迴路的圖？？只要是含有負迴路，那麼正確結果就是 負無窮。之所以能求含有負節點主要是因為 mp[i][j]=min(mp[i][j],mp[i][k]+mp[k][j]); 的關係。其實不論是否為正數或者為負數。都是有大小的。讓每步都最小，那麼結果就最小。


        二.Dijkstra演算法

        Dijkstra演算法也是算最短路徑的。它是隻能算單源最短路徑。當然你也可以把模板改了。把所有節點都遍歷一遍也就成了算多源的模板。Dijkstra演算法的主導思想是首先儲存起點(你指定的點)到任意節點的距離，然後在這些距離中找一個最小值。畢竟你是求最短路徑，肯定就是找最小的了。但是這種實現是根據動態規劃實現。然後把你找到的點加入到起點中，我們這裡的加入用的是標記。然後更新所有節點到起點的距離。然後重複就可以算出答案。
        下面來看程式碼：

//Dijkstra演算法
#include<cstdio>
#include<cstring>
#include<algorithm>
#define Inf 1<<29
using namespace std;
int mp[100][100];
int dis[100],vis[100];
int n,m;
int dij(int s){
    for(int i=1;i<=n;i++){
        vis[i]=0;
        dis[i]=mp[s][i];//初始化1節點到任意節點的距離
    }
    vis[s]=1;
    dis[s]=0;//其實前面已經初始化過了，可以不寫。
    for(int i=1;i<n;i++){
        int to=-1;
        int d=Inf;
        for(int j=1;j<=n;j++){
            if(!vis[j]&&d>dis[j]){//如果j節點還沒加入其實節點，並且1節點及加入1節點的節點到j節點有距離
                d=dis[j];
                to=j;
            }
        }
        vis[to]=1;
        for(int j=1;j<=n;j++){
            if(!vis[j]&&dis[j]>dis[to]+mp[to][j]){
                dis[j]=dis[to]+mp[to][j];//更新1節點到任意節點的距離。
            }
        }
    }
}
int main(){
    while(~scanf("%d%d",&n,&m)){
        for(int i=1;i<=n;i++){//初始化預設距離表示i節點到j節點的距離。節點相同距離為0
            for(int j=1;j<=n;j++){
                if(i!=j){
                    mp[i][j]=Inf;
                }else{
                    mp[i][j]=0;
                }
            }
        }
        for(int i=1;i<=m;i++){
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);//輸入實際a點到b點的距離
            mp[a][b]=c;
           // mp[b][a]=c;//寫上這個就是無向圖
        }
        dij(1);//這裡的1(數字1)表示我要求1這個節點到所有節點的最短距離！！！
        for(int i=2;i<=n;i++){
            printf("-->i=%d  dis[%d]=%d\n\n",i,i,dis[i]);//dis中儲存的表示1節點到任意節點的距離，當i=2時表示1節點到2節點的距離
        }
    }
    return 0;
}

這裡對於Dijkstra演算法有需要注意的地方，那就是Dijkstra演算法不能算含有負節點的圖。當然更不可能算含有負節點回路的圖。為什麼呢？？

   我們這裡就拿有向圖來解答。看圖片輸入測試資料
        3 3
        1 3 1
        1 2 2
        2 3 -5
        執行出來A-->B=2  A-->C=1肯定這樣就錯了應該是A-->B=2  A-->C=-3才對。

        這也跟程式碼有關係因為這個程式碼的思想是貪心。區域性貪心。所以會造成這樣的結果。

        三.Bellman-Ford演算法

        那麼算單源最短路徑Dijkstra演算法不能算含有負值節點的並且也不能算含有負節點回路的。那麼是否有其他演算法呢？？答案是有的，那就是Bellman-Ford演算法，

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define Inf 1<<29
struct node{
    int u,v,w;
}tu[1000];
using namespace std;

int n,m,dis[100];
int bellman_floyd(int s){
    for(int i=1;i<=n;i++){
        dis[i]=Inf;
    }
    dis[s]=0;
    for(int i=1;i<n;i++){//思考這裡為什麼是n-1次迴圈。
        for(int j=1;j<=2*m;j++){
            if(dis[tu[j].u]+tu[j].w<dis[tu[j].v]){
                dis[tu[j].v]=tu[j].w+dis[tu[j].u];//鬆弛操作。
            }
        }
    }

    for(int i=1;i<=2*m;i++){
        if(dis[tu[i].u]+tu[i].w<dis[tu[i].v])//判斷是否還能鬆弛，如果能就含有負值迴路。
            return -1;
    }
    return 1;
}
int main(){
    while(~scanf("%d%d",&n,&m)){
        for(int i=1;i<2*m;i+=2){
            int a,b,c;
            scanf("%d%d%d",&tu[i].u,&tu[i].v,&tu[i].w);
            tu[i+1].u=tu[i].v;
            tu[i+1].v=tu[i].u;
            tu[i+1].w=tu[i].w;
        }
        int x= bellman_floyd(1);
        if(x==-1){
            printf("no\n");
        }else{
            for(int i=1;i<=n;i++){
                printf("dis[%d]=%d\n",i,dis[i]);
            }
        }
    }
    return 0;
}

    為什麼是n-1次鬆弛操作。
考慮：為什麼要迴圈n-1次？
答：因為最短路徑肯定是個簡單路徑，不可能包含迴路的，
如果包含迴路，且迴路的權值和為正的，那麼去掉這個迴路，可以得到更短的路徑
如果迴路的權值是負的，那麼肯定沒有解了
圖有n個點，又不能有迴路
所以最短路徑最多n-1邊
又因為每次迴圈，至少relax一邊
所以最多n-1次就行了

我們來舉個例項。
6 5
5 6 1
4 5 2
3 4 3
2 3 4
1 2 5

    就是這組測試資料。這是最壞的一種情況了。
    那麼為什麼不能有負值環路這是另外一組測試資料。

6 6
1 2 1
2 3 -1
3 4 -1
4 5 -1
5 2 -1
5 6 1

這組資料就能很好的說明。

總結：Floyd演算法能很好的解決稠密圖(V大，V代表節點數)。而Dijkstra演算法卻能很好的解決稀疏圖(E小,E代表邊權數)。而SPFA也能很好解決稀疏圖。(後面我會寫的)

好了就說到這裡了，如果有不足的地方請指正！！！謝謝！！