最短路（hdu2544)

Time Limit: 5000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 104625 Accepted Submission(s): 44973

1.Problem Description：

在每年的校賽裏，所有進入決賽的同學都會獲得一件很漂亮的t-shirt。但是每當我們的工作人員把上百件的衣服從商店運回到賽場的時候，卻是非常累的！所以現在他們想要尋找最短的從商店到賽場的路線，你可以幫助他們嗎？

Input:輸入包括多組數據。每組數據第一行是兩個整數N、M（N<=100，M<=10000），N表示成都的大街上有幾個路口，標號爲1的路口是商店所在地，標號爲N的路口是賽場所在地，M則表示在成都有幾條路。N=M=0表示輸入結束。接下來M行，每行包括3個整數A，B，C（1<=A,B<=N,1<=C<=1000）,表示在路口A與路口B之間有一條路，我們的工作人員需要C分鐘的時間走過這條路。
輸入保證至少存在1條商店到賽場的路線。

Output:對於每組輸入，輸出一行，表示工作人員從商店走到賽場的最短時間

Sample Input
2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0

Sample Output
3
2

2.基本思路

這道題由於只有100個城市，因此不採用任何優化，只採用最簡單的Dijkstra便能通過。但爲了能夠理解Dijkstra的主要優化方法我們以該題爲例在該題的基礎上不斷地進行優化，最終達到終極版本，當你掌握了終極版本的Dijkstra算法之後，你將對Dijkstra問題無所畏懼。

3.代碼實現

3.1 $version-1$ 裸Dijkstra算法【採用鄰接鏈表和鄰接矩陣進行存取均可，當圖較爲稀疏的時候採用鄰接鏈表效率更高，但圖較爲稠密的時候採用鄰接矩陣的效率更高，但一般情況下鄰接鏈表的效率均更優】

#include <iostream>
#include <climits>
#include <vector>
#define N 101
using namespace std;

int dis[N];
int vis[N];

struct Next{
    int city;
    int time;
    Next(int _city,int _time){
        city = _city;
        time = _time;
    }
};

vector<Next> Vec[N];

int main()
{
    int n,m;
    int A,B,C;

    while(cin>>n>>m){

        if(n==0&&m==0)
            break;

        //init
        for(int i=1;i<=n;i++)
            dis[i]=-1,vis[i]=-1,Vec[i].clear();

        for(int i=0;i<m;i++){
            cin>>A>>B>>C;
            Vec[A].push_back(Next(B,C));
            Vec[B].push_back(Next(A,C));
        }

        int newP = 1;
        dis[newP] = 0;
        vis[newP] = 0;

        //dijkstra
        for(int i=0;i<n-1;i++){
            for(int j=0;j<Vec[newP].size();j++){
                int city = Vec[newP][j].city;
                int time = Vec[newP][j].time;
                if(vis[city]==0)
                    continue;
                if(dis[city]==-1||dis[city]>dis[newP]+time){
                    dis[city] = dis[newP]+time;
                }
            }

            int Min = INT_MAX;
            for(int j=1;j<=n;j++){
                if(vis[j]!=0){
                    if(~dis[j]){
                        if(dis[j]<Min){
                            Min=dis[j];
                            newP = j;
                        }
                    }
                }
            }

            vis[newP] = 0;
        }
        cout<<dis[n]<<endl;
    }
    return 0;
}

首先提交一發，好了，這就是我們優化的起點

3.2 $version-2$ 仔細想想，其實Dis[…]的更新並不一定是按順序的，因此我們只需要在dis[N]更新完之後便可以得到最終個正確答案了。

#include <iostream>
#include <climits>
#include <vector>
#define N 101
using namespace std;

int dis[N];
int vis[N];

struct Next{
    int city;
    int time;
    Next(int _city,int _time){
        city = _city;
        time = _time;
    }
};

vector<Next> Vec[N];

int main()
{
    int n,m;
    int A,B,C;

    while(cin>>n>>m){

        if(n==0&&m==0)
            break;

        //init
        for(int i=1;i<=n;i++)
            dis[i]=-1,vis[i]=-1,Vec[i].clear();

        for(int i=0;i<m;i++){
            cin>>A>>B>>C;
            Vec[A].push_back(Next(B,C));
            Vec[B].push_back(Next(A,C));
        }

        int newP = 1;
        dis[newP] = 0;
        vis[newP] = 0;

        //dijkstra
        for(int i=0;i<n-1;i++){
            for(int j=0;j<Vec[newP].size();j++){
                int city = Vec[newP][j].city;
                int time = Vec[newP][j].time;
                if(vis[city]==0)
                    continue;
                if(dis[city]==-1||dis[city]>dis[newP]+time){
                    dis[city] = dis[newP]+time;
                }
            }

            int Min = INT_MAX;
            for(int j=1;j<=n;j++){
                if(vis[j]!=0){
                    if(~dis[j]){
                        if(dis[j]<Min){
                            Min=dis[j];
                            newP = j;
                        }
                    }
                }
            }

            vis[newP] = 0;
            if(newP==n)break;
        }

        cout<<dis[n]<<endl;

    }
    return 0;
}

再提交一發！！

咦，好像沒什麼變化，估計是測試用例中特殊數據樣例比較少，別急，後面還有大招呢，我們繼續優化。

3.3 $version-3$ 是時候分析一下上面算法的時間複雜度了，一看過去兩層 $for$ 循環特別醒目，因此該算法的平均時間複雜度爲 $O(n^2)$ 。我們來分析一下兩層 $for$ 循環，第一層指的是最多一共需要選擇除了起始點外的 $n-1$ 個結點，因此這一層循環是至少需要的，不可簡化的，而第二層循環的目的呢，主要是爲了取出當前 $dis[...]$ 數組中沒有被訪問過的城市中對應最小 $dis[i]$ 的城市 $i$ ，因此其是一個求解最小值的過程，這裏我們就可以考慮採用小頂堆進行優化，這樣每次求最小值的時候，我們只需要取出堆頂的元素即可。分析算法可知，堆中元素最多可以到達 $M$ 個，也就是邊的數量。因此該算法的時間複雜度爲 $O(NlogM)$

下面放出優化之後的代碼:

#include <iostream>
#include <climits>
#include <vector>
#include <queue>
#define N 101
using namespace std;

int dis[N];
int vis[N];

struct Node{
    int id;
    int cost;
    Node(int _id,int _cost){
        id = _id;
        cost = _cost;
    }
    operator < (const Node& ano)const{
        return cost > ano.cost;
    }
};

priority_queue<Node> Que;

struct Next{
    int city;
    int time;
    Next(int _city,int _time){
        city = _city;
        time = _time;
    }
};

vector<Next> Vec[N];

int main()
{
    int n,m;
    int A,B,C;

    while(cin>>n>>m){

        if(n==0&&m==0)
            break;
        while(!Que.empty())
            Que.pop();

        //init
        for(int i=1;i<=n;i++)
            dis[i]=-1,vis[i]=-1,Vec[i].clear();

        for(int i=0;i<m;i++){
            cin>>A>>B>>C;
            Vec[A].push_back(Next(B,C));
            Vec[B].push_back(Next(A,C));
        }

        int newP = 1;
        dis[newP] = 0;
        vis[newP] = 0;

        //dijkstra
        for(int i=0;i<n-1;i++){
            for(int j=0;j<Vec[newP].size();j++){

                int city = Vec[newP][j].city;
                int time = Vec[newP][j].time;
                if(vis[city]==0)
                    continue;
                if(dis[city]==-1||dis[city]>dis[newP]+time){
                    dis[city] = dis[newP]+time;
                    Que.push(Node(city,dis[city]));
                }
            }

            while(!Que.empty()){

                if(vis[Que.top().id]!=-1){
                    Que.pop();
                    continue;
                }
                newP = Que.top().id;
                Que.pop();
                break;
            }

            vis[newP] = 0;
            if(newP==n)break;
        }

        cout<<dis[n]<<endl;

    }
    return 0;
}

3.4 $version-4$ 到這裏應該已經能過絕大部分的題目了，但仔細想想還有沒有優化的空間呢？有的，因爲我們採用了vector來作爲鄰接鏈表存儲圖的結構，而vector是STL封裝的高級數據結構，因此訪問時間一般比簡單的整數數組來的慢，因此這裏可以採用鏈式前向星來存取整圖的結構，對於卡常的代碼還是值得嘗試採用該種方法來試一試。先貼出代碼和運行結果：

#include <iostream>
#include <climits>
#include <vector>
#include <queue>
#include <memory.h>
#define N 101
#define M 10001
using namespace std;

struct Node{
    int id;
    int cost;
    Node(int _id,int _cost){
        id = _id;
        cost = _cost;
    }
    operator < (const Node& ano)const{
        return cost > ano.cost;
    }
};

struct Edge{
    int next;//下條同起點的邊的編號
    int to;//該邊的終止點的編號
    int w;//該邊所具有的權重
}edge[M];

priority_queue<Node> Que;

int dis[N];
int vis[N];
int head[N];
int tot;

void init() {
    tot = 0;
    memset(head, -1, sizeof(head));
}

void add_Edge(int u,int v,int w){
    edge[tot].to=v;
    edge[tot].w=w;
    edge[tot].next=head[u];
    head[u]=tot++;
}

int main()
{
    int n,m;
    int A,B,C;

    while(cin>>n>>m){
        //init
        init();
        for(int i=1;i<=n;i++)
            vis[i]=0,dis[i]=0x3f3f3f3f;

        if(n==0&&m==0)
            break;

        while(!Que.empty())
            Que.pop();


        for(int i=0;i<m;i++){
            cin>>A>>B>>C;
            add_Edge(A,B,C);
            add_Edge(B,A,C);
        }

        int newP = 1;
        dis[newP] = 0;
        vis[newP] = 1;

        //dijkstra
        for(int i=0;i<n-1;i++){
            for(int j=head[newP];~j;j=edge[j].next){
                int city = edge[j].to;
                int time = edge[j].w;
                if(vis[city]!=1&&dis[city]>dis[newP]+time){
                    dis[city] = dis[newP]+time;
                    Que.push(Node(city,dis[city]));
                }
            }

            while(!Que.empty()){

                if(vis[Que.top().id]!=0){
                    Que.pop();
                    continue;
                }
                newP = Que.top().id;
                Que.pop();
                break;
            }

            vis[newP] = 1;
            if(newP==n)break;
        }

        cout<<dis[n]<<endl;
    }
    return 0;
}

最終運行的時間沒有多大的變化，主要還是該問題的數據規模比較小，但規模比較大的時候效果就比較明顯了。

關於前向星有以下兩篇文章值得參考：
https://blog.csdn.net/acdreamers/article/details/16902023
https://blog.csdn.net/lookqaq/article/details/81304637

最後爲了證明優化的意義，不凡請各位看官移步hdu3790親自感受一下優化的魅力之所在。
以下是我最終AC的代碼：https://paste.ubuntu.com/p/gtW7ypFhRG/

4.Summary：

最後讓我們一起來總結一下，這篇文章的優化過程，首先我們採用了裸Dijkstra的代碼直接跑通，隨後觀察到可以判斷終點的更新來提前終止算法，接下來我們分析了前面算法的時間複雜度，採用小頂堆來選取最小距離的結點將複雜度從 $O(n^2)$ 直接降到了 $O(NlogM)$ 。最後，我們考慮採用鏈式前向星來優化圖的存儲，相比於Vector數據結構存儲圖，其訪問圖中邊的效率得到了提高，以上。

單源最短路(優化篇之Dijkstra)

最短路（hdu2544)

Time Limit: 5000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 104625 Accepted Submission(s): 44973

1.Problem Description：

2.基本思路

3.代碼實現

4.Summary：

Win10 LTSC 2019 安裝後的一些步驟

推薦2款開源、美觀的WinForm UI控件庫

NET9 AspnetCore將整合OpenAPI的文檔生成功能而無需三方庫

在Linux下管理MySQL的大小寫敏感性

Bug Report Classification Summary

2019年暑期夏令營(題目記錄篇)

Action Recognition from Single Timestamp Supervision in Untrimmed Videos（QA）

單源最短路(優化篇之Dijkstra)

表達式求值

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結