0016：單源最短路徑（dijkstra演算法）

題目連結：https://www.luogu.com.cn/problem/P4779

題目描述：給定一個 n 個點，m 條有向邊的帶非負權圖，計算從 s 出發，到每個點的距離。

 

 

 

 

這道題就是一個單源最短路徑的模板，有兩種做法：

1.Floyd演算法

暴力列舉出所有起點、終點以及中間值，然後算出每兩個點間的最小值。

但這個演算法時間複雜度較高，是O（n^3），很容易爆掉，在這道題甚至拿不到分。

程式碼：

#include<bits/stdc++.h>
using namespace std;
int arr[10000][10000];
int main(){
    int n,m,s,i,j,k,a,b,c;
    cin>>n>>m>>s;
    for(i=1;i<=n;i++){
        for(j=1;j<=n;j++){
            if(i==j){
                arr[i][j]=0;
            }else{
                arr[i][j]=99999999;
            }
        }
    }
    while(m--){
        cin>>a>>b>>c;
        arr[a][b]=min(c,arr[a][b]);
    }
    for(k=1;k<=n;k++){
        for(i=1;i<=n;i++){
            if(i==k||arr[i][k]==99999999){
                continue;
            }
            for(j=1;j<=n;j++){
                arr[i][j]=min(arr[i][j],arr[i][k]+arr[k][j]);
            }    
        }
    }
    for(i=1;i<=n;i++){
        cout<<arr[s][i]<<" ";    
    }
}

 

 這道題我們要用一種更高階的演算法——

2.dijkstra演算法

在無負權邊的情況下，時間複雜度為 O（n log n）基本可以順利通過所有模板題。

先確定初始點到其他所有點的路徑（可能為無窮），然後從和該點距離最小點開始遍歷，不斷更新這些點與初始點的最小距離（學術名叫鬆弛），最後求出初始點與所有其他點的最短路。

然後要通過此題，還需要前向星存邊和優先佇列（堆）優化，可能比較難理解，自己畫圖模擬即可。

上程式碼（有註釋）：

#include<bits/stdc++.h>
using namespace std;
long long vis[100001]={0},head[100001],dis[100001],cnt,n,m,s,a,b,c;
long long INF=2147483647;//2的31次方，可以看做無窮 
struct Q{
    int a,b,c,next;
};//鄰接表，在有向圖中儲存起點、終點權值，next用來前向星存邊 
struct node{//放進優先佇列中的結構體 
    int w,now;//w為最短路，now為點 
    bool operator <(const node &x)const{
        return w>x.w;//權值從大到小排 
    }
};
priority_queue<node> q;//優先佇列 
Q e[500001];
void add(int a,int b,int c){//前向星存邊 
    e[cnt++].a=a;
    e[cnt].b=b;
    e[cnt].c=c;
    e[cnt].next=head[a];//next儲存上一個cnt值，方便for迴圈從後往前遍歷邊 
    head[a]=cnt;
} 
void dijkstra(){
    for(int i=1;i<=n;i++){
        dis[i]=INF;
    }
    dis[s]=0;
    q.push((node){0,s});//將起點壓入佇列 
    while(!q.empty()){//佇列非空 
        node x=q.top();//彈出堆頂（最小）元素 
        q.pop();
        int u=x.now;
        if(vis[u]==1){
            continue;//遍歷完無需再遍歷 
        }
        vis[u]=1;
        for(int i=head[u];i;i=e[i].next){//用前向星遍歷 
            int v=e[i].b; 
            dis[v]=min(dis[v],dis[u]+e[i].c);//鬆弛操作 
            q.push((node){dis[v],v});
        }
    }
}
int main(){
    cin>>n>>m>>s;
    for(int i=0;i<m;i++){
        cin>>a>>b>>c;
        add(a,b,c);
    }
    dijkstra(); 
    for(int i=1;i<=n;i++){
        cout<<dis[i]<<" ";
    }
}