使用Dijkstra算法求由顶点a到顶点h的最短路径

1. 问题

对于下图使用Dijkstra算法求由顶点a到顶点h的最短路径。

 

2. 解析

Dijkstra算法采用的是一种贪心的策略，声明一个数组dis来保存源点到各个顶点的最短距离和一个保存已经找到了最短路径的顶点的集合：T，初始时，原点 s 的路径权重被赋为 0 （dis[s] = 0）。若对于顶点 s 存在能直接到达的边（s,m），则把dis[m]设为w（s, m）,同时把所有其他（s不能直接到达的）顶点的路径长度设为无穷大。初始时，集合T只有顶点s。

 

然后，从dis数组选择最小值，则该值就是源点s到该值对应的顶点的最短路径，并且把该点加入到T中，OK，此时完成一个顶点，

 

然后，我们需要看看新加入的顶点是否可以到达其他顶点并且看看通过该顶点到达其他点的路径长度是否比源点直接到达短，如果是，那么就替换这些顶点在dis中的值。

 

然后，又从dis中找出最小值，重复上述动作，直到T中包含了图的所有顶点。

3. 设计

for (int i = 1; i <= n - 1; ++i) {

min = inf;

int u;

for (int j = 1; j <= n; ++j) {

if (book[j] == 0 && dis[j] < min) {

min = dis[j];

u = j;

}

}

book[u] = 1;

for (int v = 1; v <= n; ++v) {

if (edge[u][v] < inf) {

if (dis[v] > dis[u] + edge[u][v])

dis[v] = dis[u] + edge[u][v];

}

}

}

4. 分析

该算法复杂度为O(n^2)

5. 源码

#include<iostream>

#include<cstdio>

#define MAXN 2147483647

using namespace std;

int n,m,s;

struct G{

    int u;

    int v;

    int w;

    int next;

}e[500001];

int head[500001];

int d[500001];

int read(){

    int num=0;

    char ch=getchar();

    while(ch<'0' || ch>'9') ch=getchar();

    while(ch>='0' && ch<='9'){

        num=num*10+ch-'0';

        ch=getchar();

    }

    return num;

}

bool v[500001];

int main(){

    int i,j;

    n=read();

    m=read();

    s=read();

    for(i=1;i<=m;i++){

        int a=read(),b=read(),c=read();

        e[i].u=a;

        e[i].v=b;

        e[i].w=c;

        e[i].next=head[a];

        head[a]=i;

    }

    for(i=1;i<=n;i++) d[i]=MAXN; //初始化

    d[s]=0;

    for(i=1;i<=n;i++){

        int k=0,minn=MAXN;

        for(j=1;j<=n;j++) //寻找距离最小的点

          if(minn>d[j] && !v[j]){

              minn=d[j];

              k=j;

          }

        v[k]=1; //标记为访问过

        for(j=head[k];j!=0;j=e[j].next)

            if(!v[e[j].v] && d[e[j].v]>d[e[j].u]+e[j].w) //更新节点

            d[e[j].v]=d[e[j].u]+e[j].w;

    }

    for(i=1;i<=n;i++) cout<<d[i]<<" ";

    return 0;

}