最短路徑算法之Dijkstra's algorithm

Dijkstra's algorithm主要用來解決單源最短路徑的問題，並且不可以用於包含負權值的圖。

主要思想就是：把一個圖上的點分成兩類，一類是最短路徑樹上所包含的點記作集合S，另一類當然就不是最短路徑上的點記作集合V；怎麼確定哪個點能夠屬於S呢？遍歷圖上的所有的點，找出距離起始點的路徑最短的那個點，把他放入集合S中，然後在更新圖上所有點離起始點的距離信息，就是比較經過剛剛放入S中的這個點和不經過這個點距離，選取最小的，然後再次遍歷所有的點，重複上述步驟，直至所有的點都放入集合S中。

代碼如下：

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

static const int INF=0x3f3f3f3f;
static const int maxn=1000;
static const int white=0;
static const int gray=1;
static const int black=2;
int dis[maxn],G[maxn][maxn];//圖是用鄰接矩陣表示
int visit[maxn];

void dijkstra(int s,int n)//起始點s，圖中所有點的個數n；
{
    int minv;
    memset(dis,INF,sizeof(dis));
    memset(visit,white,sizeof(visit));
    dis[s]=0;visit[s]=gray;
    while(1)
    {
        minv=INF;
        int u=-1;
        for(int i=0;i<n;i++)
        {
            if(minv>dis[i]&&visit[i]!=black)
            minv=dis[i],u=i;
        }
        if(u==-1) break;
        visit[u]=black;
        for(int v=0;v<n;v++)
        {
            if(visit[v]!=black&&G[u][v]!=INF)
            {
                dis[v]=min(dis[v],dis[u]+G[u][v]);
                visit[v]=gray;
            }
        }
    }
}


int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    memset(G[i],INF,sizeof(G[i]));
    for(int i=0;i<n;i++)
    {
        int u,t;
        cin>>u>>t;
        while(t--){
            int v,w;
            cin>>v>>w;
            G[u][v]=w;// 這裏圖中點的編號是從0開始
        }
    }
    dijkstra(0,n);
    for(int i=0;i<n;i++)
    cout<<i<<" "<<dis[i]<<endl;
    return 0;
}

這是用鄰接矩陣表示，算法複雜度爲O（）;爲複雜，下面介紹堆優化，使這個算法產生質的飛躍，從而常居最短路徑四大算法之一；

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <queue>

using namespace std;

static const int maxn=10000;//點的個數
static const int INF=0x3f3f3f3f;
static const int white=0;
static const int gray=1;
static const int black=2;
vector<pair<int,int> > G[maxn];
int visit[maxn],dis[maxn],pre[maxn];

void dijkstra(int s)
{
    priority_queue<pair<int ,int>,vector<pair<int,int> >,greater<pair<int,int> > >PQ;
    memset(visit,white,sizeof(visit));
    memset(dis,INF,sizeof(dis));
    dis[s]=0;visit[s]=gray;pre[s]=s;
    PQ.push(make_pair(dis[s],s));
    while(!PQ.empty())
    {
        pair<int,int>start=PQ.top();
        PQ.pop();
        int u=start.second;
        visit[u]=black;
//        if(dis[u]>start.first) continue;
        for(int i=0;i<G[u].size();i++)
        {
            int v=G[u][i].second;
            if(visit[v]!=black)
            {
                if(dis[v]>dis[u]+G[u][i].first)
                {
                    dis[v]=dis[u]+G[u][i].first;
                    PQ.push(make_pair(dis[v],v));
                    pre[v]=u;
                }
                visit[v]=gray;
            }
        }
    }
}

int main()
{
    int n,u,k,v,w;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>u>>k;
        while(k--){
            cin>>v>>w;
            G[u].push_back(make_pair(w,v));
        }
    }
    dijkstra(0);
    for(int i=0;i<n;i++)
    cout<<i<<" "<<dis[i]<<endl;
    int end;
    cin>>end;
    int p=end;
    while(1)
    {
        int father=pre[end];
        if(father==end) break;
        cout<<pre[end]<<" ";//輸出路徑
        end=pre[end];
    }
    return 0;
}

還有一種鏈式前向星表示圖，然後用堆的dijistra

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <queue>

using namespace std;

static const int maxn=10000;//點的個數
static const int INF=0x3f3f3f3f;
static const int white=0;
static const int gray=1;
static const int black=2;

struct Edge{
    int w;//權值
    int end;//終點
    int next;//下一條邊的位置
}edge[maxn<<1];//邊的集合
int head[maxn<<1];//頂點的第一條邊所在的位置
int cnt=0;
void add(int u,int v,int w)
{
    edge[cnt].w=w;
    edge[cnt].end=v;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}
//以上是鏈式前向星的表示

int visit[maxn],dis[maxn],pre[maxn];

void dijkstra(int s)
{
    priority_queue<pair<int ,int>,vector<pair<int,int> >,greater<pair<int,int> > >PQ;
    memset(visit,white,sizeof(visit));
    memset(dis,INF,sizeof(dis));
    dis[s]=0;visit[s]=gray;pre[s]=s;
    PQ.push(make_pair(dis[s],s));
    while(!PQ.empty())
    {
        pair<int,int> u=PQ.top();PQ.pop();
        int x=u.second;
        if(visit[x]==black) continue;
        visit[x]=black;
        for(int i=head[x];i!=-1;i=edge[i].next)
        {
            if(dis[edge[i].end]>dis[x]+edge[i].w)
            {
                dis[edge[i].end]=dis[x]+edge[i].w;
                PQ.push(make_pair(dis[edge[i].end],edge[i].end));
                visit[edge[i].end]=gray;
                pre[edge[i].end]=x;
            }
        }
    }
}

int main()
{
    memset(head,-1,sizeof(head));//一定要在主函數中聲明
    int n,u,k,v,w;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>u>>k;
        while(k--){
            cin>>v>>w;
            add(u,v,w);
        }
    }
    dijkstra(0);
    cout<<"*************"<<endl;
    for(int i=0;i<n;i++)
    cout<<i<<" "<<dis[i]<<endl;
    cout<<"**************"<<endl;
    int end;
    cin>>end;
    int p=end;
    while(1)
    {
        int father=pre[end];
        if(father==end) break;
        cout<<pre[end]<<" ";//輸出路徑
        end=pre[end];
    }
    return 0;
}