最短路問題（——模板習題與總結）

　　摘要：本文主要講解在競賽中如何求解圖中存在環的最短路問題。其中涉及的算法有Floyd算法，Dijkstra算法，使用鄰接表和優先隊列優化的Dijkstra算法，Bellman-Ford算法，簡要總結各算法的基本思想和實現以及使用注意事項。

　　最短路問題主要分為單源最短路問題和多源最短路問題。給出頂點數和邊數，以及邊的權值，讓我們計算從某個頂點到某個頂點的最短路徑，單源最短路就是求其中一個頂點到其他各個頂點的最短路，多源最短路就是求解任意兩點間的最短路。

　　先總結一下只有五行的Floyd算法，一句話概括就是：從i號頂點到j號頂點只經過前k號頂點松弛過的最短路徑。

　　模板習題：http://www.cnblogs.com/wenzhixin/p/7327981.html

　　AC代碼：

#include<stdio.h>
int main()
{
    int n,m,e[210][210],inf=99999999,t1,t2,t3,s,t,i,j,k;
    while(scanf("%d%d",&n,&m) != EOF)
    {
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                if(i==j)
                e[i][j]=0;
                else
                e[i][j]=inf;
            }
        }
        for(i=1;i<=m;i++)
        {
            scanf("%d%d%d",&t1,&t2,&t3);
            if(e[t1][t2] > t3)//道路可能存在重復，去最小值即可 
            e[t1][t2]=e[t2][t1]=t3;
        }
        scanf("%d%d",&s,&t);
        
        for(k=0;k<n;k++)
            for(i=0;i<n;i++)
                for(j=0;j<n;j++)
                if(e[i][j] > e[i][k]+e[k][j])
                e[i][j]=e[i][k]+e[k][j];
        if(e[s][t]==inf)
        printf("-1\n");
        else
        printf("%d\n",e[s][t]);
    }
    return 0;
}

　　該算法的優勢在於可以計算頂點數不太多的圖的任意兩點的最短路徑，很容易實現求解多源最短路徑。

　　缺點在於不能計算頂點數太多的圖的最短路徑，一是二維數組開不了那么大，二是該算法時間復雜度太高，達到O（n*n*n），很容易超時（超過1000個頂點就不能使用）。另外該算法可以解決帶負權邊的圖，並且均攤到每一對點上，但是不能解決帶有負權回路的圖（其實如果一個圖中存在負權回路，那么該圖就不存在最短路徑了）。

　　接下來，總結一下求解單源最短路徑常用的Dijkstra算法。

　　基本步驟：1. 將所有的頂點分為兩個集合，已知最短路徑的頂點集合P和未知最短路徑的頂點集合Q。起初，已知最短路徑的頂點集合P中只有一個源點這一個頂點，我們還需要有一個數組來記錄哪些頂點在集合P中，哪些在集合Q中。比如可以用book數組進行標記，當book[i]=1;表示i號頂點在集合P中，當book[i]=0;表示i號頂點在集合Q中。

　　　　　　　2. 設置源點s到自己的最短路徑為0即dis[s]=0;,如果存在有源點能夠直接到達的頂點i，則將dis[i]賦值為e[s][i]；如果不存在該源點直接到達的頂點i，則將

dis[i]賦值正無窮大。

　　　　　　　3. 在集合Q的所有頂點中選擇一個離源點最近的頂點u加入到集合P。並考察所有以u為起點的邊，對每一條路徑進行松弛操作。

　　　　　　　4. 重復第3步，如果P集合為空，算法結束。

　　模板習題：http://www.cnblogs.com/wenzhixin/p/7387613.html

　　AC代碼：

#include<stdio.h>
#include<string.h>
int e[1010][1010],dis[1010],bk[1010];
int main()
{
    int i,j,min,t,t1,t2,t3,n,u,v;
    int inf=99999999;
    while(scanf("%d%d",&t,&n)!=EOF)
    {
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=n;j++)
            {
                if(i==j)
                e[i][j]=0;
                else
                e[i][j]=inf;
            }
        }
        for(i=1;i<=t;i++)
        {
            scanf("%d%d%d",&t1,&t2,&t3);
            if(e[t1][t2]>t3)
            {
                e[t1][t2]=t3;
                e[t2][t1]=t3;
            }
        }
        for(i=1;i<=n;i++)
            dis[i]=e[1][i];
        memset(bk,0,sizeof(bk));
        bk[1]=1;
        for(i=1;i<=n-1;i++)
        {
            min=inf;
            for(j=1;j<=n;j++)
            {
                if(bk[j]==0&&dis[j]<min)
                {
                    min=dis[j];
                    u=j;
                }
            }
            bk[u]=1;
            for(v=1;v<=n;v++)
            {
                if(e[u][v]<inf && dis[v]>dis[u]+e[u][v])
                        dis[v]=dis[u]+e[u][v];
            }
        }
        printf("%d\n",dis[n]);
    }
    return 0;
}

　　不過競賽題大多是對Dijkstra算法的變形應用，例如求解最短路徑的最大權值，最長路徑的最小權值。

　　最長路徑的最小權值：http://www.cnblogs.com/wenzhixin/p/7336948.html

　　最短路徑的最大權值：http://www.cnblogs.com/wenzhixin/p/7412176.html

　　其實懂得了算法基本思想，根據要求稍微變化一下就好了。

 　  上述算法的時間復雜度為O（n*n），還是很高的，對於一些要求高的題目需要使用進一步優化的算法，時間復雜度是O（mlogn），下面借鑒《算法入門經典》中的優化算法進行講解。具體的優化方法是使用鄰接表存圖，再使用優先隊列優化。使用vector數組保存邊的編號，遍歷從某一頂點出發的所有邊，更新d數組，就可以寫成“for(int i = 0; i < G[u].size(); i++) 更新操作;”。使用優先隊列保證每次彈出的是d值最小的結點，並彈出結點編號，方便后序松弛操作。

代碼實現如下：

#include<vector>
#include<queue> 
#include<cstring>
#include<cstdio>
using namespace std;

const int INF = 99999999;
const int maxn = 1001;

struct Edge{
    int from, to, dist;
    Edge(int u, int v, int d) :from(u), to(v), dist(d) { };//注釋1 
};

//使用優先隊列存儲的結點 
struct HeapNode {
    int d, u;//最小的d值及其結點編號
    bool operator < (const HeapNode& a) const {//注釋2 
        return d > a.d;
    } 
}; 

//為了使用方便，將算法中用到的數據結構封裝在一個結構體中，有點類的意思，實際上結構體和類只是在權限上有一點差別
struct Dijkstra{
    int n, m;
    vector<Edge> edges; //使用vector數組存儲鄰接表，更容易理解，
    vector<int> G[maxn];
    bool done[maxn];    //標記數組
    int d[maxn];        //s到各個頂點的最短路徑
    int p[maxn];        //最短路中的上一條弧
    
    void init(int n){//初始化 
        this->n = n; //注釋3 
        for(int i = 0; i < n; i++)
            G[i].clear();//清空鄰接表 
        edges.clear();     //清空邊表 
    }    
    
    void AddEdge(int from, int to, int dist) {//添加邊 
        edges.push_back(Edge(from, to, dist));
        m = edges.size();//每加入一條邊對其進行編號
        G[from].push_back(m - 1);//以from為起點的邊的編號分別是多少 
    }
    
    void dijkstra(int s){//Dijkstra 
        priority_queue<HeapNode> q;
        
        for(int i = 0; i < n; i++)    d[i] = INF;
        d[s] = 0;
        
        memset(done, 0, sizeof(done));
        q.push((HeapNode){0, s});
        
        while(!q.empty()){
            HeapNode x = q.top();
            q.pop();
            int u = x.u;
            
            if(done[u])    continue;
            done[u] = 1;
            
            for(int i = 0; i < G[u].size(); i++){//遍歷所有從u出發的邊 
                Edge e = edges[G[u][i]];
                if(d[e.to] > d[u] + e.dist){//更新s到e.to的最短距離 
                    d[e.to] = d[u] + e.dist;
                    
                    p[e.to] = G[u][i];//記錄使用編號為G[u][i]的邊走到e.to這個頂點 
                    q.push((HeapNode){d[e.to], e.to});//加入d[e.to]及其結點的編號表示可以從這個點松弛其他路徑 
                }
            }
        }
    } 
};

int main()
{
    //有了結構體的封裝，使用的時候操作如下 
    struct Dijkstra solver;//類似定義一個求解單源最短路的對象，有一點需要特別注意，當圖特別大的時候要將此語句放在主函數外
    //原因是局部變量沒有太大的存儲空間，所以需要變成全局變量 
    int n,m;
    scanf("%d%d",&n, &m); // 讀入頂點數和邊的條數
    solver.init(n);//將鄰接表清空 
     
    for(int i = 0; i < m; i++){
        int u, v, w;
        scanf("%d%d%d",&u, &v, &w);//注意點的編號是從0開始還是從1開始
        u--; v--;//如果是從1開始計數的，需要減1
        solver.AddEdge(u, v, w);//如果雙向路需要反過來再調用一次即可 
    } 
    
    solver.dijkstra(0); //求頂點0到其他各個頂點的最短距離,注意減1 
    
    //如何使用p數組打印最短路徑的方案
    for(int i = 1; i < solver.n; i++){
        printf("從1到%d的最短路徑方案是：\n", i+1);
        
        vector<int> path;//取出路徑編號，倒序輸出結點 
        int tmp = i;
        do {
            tmp = solver.p[tmp];
            path.push_back(tmp);
        }while(solver.edges[tmp].from != 0);
        
        for(int j = path.size() - 1; j >= 1; j--){
            printf("%d->%d,", solver.edges[path[j]].from+1, solver.edges[path[j]].to+1);
        }
        printf("%d->%d\n", solver.edges[path[0]].from+1, solver.edges[path[0]].to+1);
        
        printf("最短距離是%d\n", i+1, solver.d[i]);
    } 
    return 0;
}
/*
5 5
1 2 20
2 3 30
3 4 20
4 5 20
1 5 100
*/

　　程序中有三個注釋分別如下：

　　注釋1，初始化列表，作用就是給邊的各個屬性賦值。

　　注釋2，操作符重載重const的使用，第一個const保證這個結構體中的變量不被修改，第二個const保證之前的結構體const不被修改。

　　注釋3，this指針，當參數與成員變量名相同時使用this指針，如this->n = n （不能寫成n = n）。

　　測試樣例結果如圖：

     

這里給出一道練習題http://acm.hdu.edu.cn/showproblem.php?pid=1535，參考解答https://www.cnblogs.com/wenzhixin/p/9062574.html。

　　可以發現，當一個圖中存在負權邊的時候，不一定存在最短路，當存在最短路的時候，Dijkstra算法就不適用了，因為松弛過程中會不斷找到更短的“松弛路徑”，導致最短路徑為負，顯然是不正確的。這就需要Bellman-Ford算法來解決圖中帶有負權邊的單源最短路問題了。

　　如果說Dijkstra算法是操作結點來進行路徑松弛的話，那么Bellman-Ford算法就是操作邊來松弛路徑了。代碼如下：

/*
n為頂點數，m為邊數
邊的描述為u[i]->v[i]的權值為w[i] 
*/ 
for(int j = 1; j <= n-1; j++){
    for(int i = 1; i <= m; i++){
        if(d[v[i]] > d[u[i]] + w[i])
            d[v[i]] > d[u[i]] + w[i];
    }
}

　　內層循環m次，意思就是依次枚舉每一條邊，如果u[i]->v[i]這條邊能使源點到v[i]的距離變短，就更新d[v[i]]的值。為什么外層循環需要n-1次呢，因為在一個含有n個頂點的，不包含負環的圖中，最短路最多經過n-1個點（因為不包括起點），通過n-1輪松弛就可以得到。

　　反過來說，如果經過n-1輪松弛后，還能更新，就說明圖中存在負環。利用這個特性還可以用Bellman-Ford算法判斷圖中是否存在負環。具體例子如POJ 3259 Wormholes

　　AC代碼：

/*
題意描述
第一行輸入n個頂點和m條邊以及蟲洞的個數
接下來輸入m行邊，a->b花費的時間是c
接下來wn行是蟲洞的描述，a->b可以回到c秒前，也就是-c
問這個人能不能回到遇到之前的自己，也就是是否存在負環。 
*/ 
#include<cstdio>
const int INF = 99999999;
const int maxn = 510;
int u[maxn*15], v[maxn*15], w[maxn*15];
int n, m, wn, pn;
int Bellman_Ford();

int main()
{
    int F;
    while(scanf("%d", &F) != EOF){
        while(F--) {
            scanf("%d%d%d", &n, &m, &wn);
            int a, b, c;
            pn = 1;
            for(int i = 1; i <= m; i++) {
                scanf("%d%d%d", &a, &b, &c);
                u[pn] = a; v[pn] = b; w[pn++] = c;
                u[pn] = b; v[pn] = a; w[pn++] = c; 
            } 
            for(int i = 1; i <= wn; i++) {
                scanf("%d%d%d", &a, &b, &c);
                u[pn] = a; v[pn] = b; w[pn++] = -c;
            }
            pn --;
            //利用pn計數每條邊
             
            if(Bellman_Ford())
                printf("YES\n");
            else
                printf("NO\n");
        } 
    }
    return 0;
}

int Bellman_Ford() {
    int dis[maxn];
    for(int i = 1; i <= n; i++){
        dis[i] = INF;
    }
    dis[1] = 0;
    
    for(int i = 1; i <= n - 1; i++) {
        for(int j = 1; j <= pn; j++) {
            if(dis[v[j]] > dis[u[j]] + w[j])
                dis[v[j]] = dis[u[j]] + w[j];
        }
    }
    
    int flag = 0;//標記，如果還能更新就說明存在環 
    for(int j = 1; j <= pn; j++) {
            if(dis[v[j]] > dis[u[j]] + w[j])
                flag = 1;
    }
    if(flag)
        return 1;
    return 0;
}

　　不過可惜的是這個算法時間復雜度太高，在競賽中我們利用隊列非空循環一直進行松弛，在含有n個頂點的圖中，如果不存在負環，包括源點在內的任意兩點間的最短路徑所利用點不超過n個，如果一個點被用超過n次，就說明有多余的點松弛最短路徑，只能說明存在負環。不存在負環，結點的標記不會取消，計算最短路徑，直至隊列為空，返回不存在負環。代碼如下：

bool bellman_ford(int s) {
    queue<int> q;
    memset(inq, 0, sizeof(inq));
    memset(cnt, 0, sizeof(cnt));
    
    for(int i = 0; i < n; i++)
        d[i] = INF;
    d[s] = 0;
    inq[s] = true;
    q.push(s);
    
    while(!q.empty()){
        int u = q.front();
        q.pop();//彈出一個點
        intq[u] = 0;
        
        for(int i = 0; i < G[u].size(); i++){//枚舉以該點為起點的每一條邊
            Edge e = edges[G[u][i]];
            if(d[u] < INF && d[e.to] > d[u] + e.dist) {//如果該邊能夠使源點到d[e.to]的距離變小，就更新  
                d[e.to] = d[u] + e.dist;
                p[e.to] = G[u][i];
                if(!inq[e.to]){//沒有被標記過 
                    q.push(e.to);
                    inq[e.to] = 1;
                    if(++cnt[e.to] > n)//如果彈出過程中，某一個點進隊了n+1次，直接判定存在負環 
                        return 0;
                }
            }
        }
    }
    return 1;
}

　　上面的寫法和優化后Dijkstra算法很像，不同的是它能讓一個節點多次進入FIFO隊列，從而判斷是否存在負環，同時也能計算最短路徑。使用的時候也用結構體封裝一下就能像優化后的Dijkstra算法一樣使用了。Bellman-Ford算法不論從思想上還是實現上都很成熟，在實際應用中也很廣泛，也有人稱隊列優化后的Bellman-Ford算法為SPFA（Shortest Path Faster Algorithm）算法。

　　下面給出一道例題：POJ 1860 Currency Exchange 參考解答：https://www.cnblogs.com/wenzhixin/p/9383074.html

　　至此，最短路問題的求解的幾種常見算法就介紹完了，各有個的優點，Foley算法，精簡，能解決帶負權邊但不存在負環的圖的最短路問題，但時間復雜度高，Dijkstra算法時間復雜度低，但是不能求解有負權邊的圖的最短路問題，Bellman-Ford算法相對比較完美，但是據說競賽的時候有很小的可能被惡意數據卡死。因此需要我們在競賽中根據具體問題，選擇合適的算法才行。