最短路径算法之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;
}