Dijkstra算法构造单源点最短路径

迪杰斯特拉(Dijkstra)算法

是求从某个源点到其余各顶点的最短路径，即对已知图 G=（V，E），给定源顶点 s∈V，找出 s 到图中其它各顶点的最短路径。

我总结下核心算法，伪代码如下：

Dijkstra()
{
    初始化Dist、Path、final
    
    // 每次求得v0到某顶点v的最短路径
    while (图的顶点数-1)
    {
        1. 找到非最短路径顶点集中距V0最近的顶点v 得到其顶点下标和距离
           将v加入到最短距离顶点集合中
           打印相关内容

        2. 依次修改其它未得到最短路径顶点的Dist[k]值
           假设求得最短路径的顶点为u，
           则 Dist[k] ＝min( Dist[k], Dist[u] + G.arcs[u][k] )
           同时修改Path[k]:Path[k] = Path[u] +G.vex[k]
    }
}

实例：

源代码：

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
using namespace std;

#define MAX_VERTEX_NUM 100
#define MAX_EDGE_NUM 200
#define MAX_VERTEX_NAMELEN 100
#define INF 65535

typedef struct{
    char name[MAX_VERTEX_NAMELEN];
}VerType;

// 图的邻接矩阵存储结构
typedef struct{
    int VertexNum,EdgeNum;                        // 顶点数，边数
    VerType Vertex[MAX_VERTEX_NUM];               // 顶点集
    int Edge[MAX_VERTEX_NUM][MAX_VERTEX_NUM];     // 边集
}MGragh;

// 邻接矩阵建图
void CreateMGragh(MGragh *Gra)
{
    int i,j,k,w;
    char v1[MAX_VERTEX_NAMELEN],v2[MAX_VERTEX_NAMELEN];
    
    printf("请输入顶点数及边数(顶点数 边数)\n");
    scanf("%d %d%*c",&(Gra->VertexNum),&(Gra->EdgeNum));
    
    printf("请输入顶点信息\n");
    for (i=0; i<Gra->VertexNum; i++){
        printf("%d.",i+1);
        gets(Gra->Vertex[i].name);
    }
    
    // 初始化邻接矩阵
    for (i=0; i<Gra->VertexNum; i++){
        for (j=0; j<Gra->VertexNum; j++){
            if (i==j){
                Gra->Edge[i][j] = 0;        // 各点到自己的距离为0
            }
            else{
                Gra->Edge[i][j] = INF;        // 各点到不相邻的点距离为无穷
            }
        }
    }

    printf("请输入边信息(顶点，顶点，权值)\n");
    for (i=0; i<Gra->EdgeNum; i++){
        printf("%d.",i+1);
        scanf("%[^,]%*c%[^,]%*c%d%*c",v1,v2,&w);

        for (j=0; j<Gra->VertexNum; j++){
            for (k=0; k<Gra->VertexNum; k++){
                if (strcmp(Gra->Vertex[j].name,v1) == 0 && strcmp(Gra->Vertex[k].name,v2) == 0){
                    Gra->Edge[j][k] = w;
                }
            }
        }
    }
}

int Dist[MAX_VERTEX_NUM];            // 存储VO到各点的最短路径的权值和
string ShortPath[MAX_VERTEX_NUM];    // 存储V0到各点的最短路径

void ShortPathByDijkstra(MGragh *Gra,int vo)
{
    printf("\n最短路径为:\n");
    int v,w,k,min;
    int final[MAX_VERTEX_NUM];    // final[w]=1 表示已经求得顶点V0到Vw的最短路径

    // 初始化数据
    for (v=0; v<Gra->VertexNum; v++){
        final[v] = 0;                    // 全部顶点初始化为未找到最短路径
        Dist[v] = Gra->Edge[vo][v];        // 将与vo点有连线的顶点加上权值
        if (Dist[v] != INF && Dist[v] != 0){
            ShortPath[v] += Gra->Vertex[vo].name;
            ShortPath[v] += Gra->Vertex[v].name;
        }
        else{
            ShortPath[v] = "";
        }    // 记录由V0连出去的边的路径 如AB、AC
    }
    Dist[vo] = 0;        // v0到自己的路径为0
    final[vo] = 1;        // 标记已经找到v0到自己的最短路径

    // 每次求得vo到某顶点V的最短路径
    for (v=1; v<Gra->VertexNum; v++){
        min = INF;

        // 将某点加入最短路径顶点集
        for (w=0; w<Gra->VertexNum; w++){
            if (final[w] == 0 && Dist[w]<min){
                k = w;
                min = Dist[w];
            }
        }    // 找到非最短路径顶点集中距V0最近的顶点 得到其顶点下标和距离
        final[k] = 1;    // 将目前找到最近的顶点置1 即将该点加入最短路径顶点集
        printf("%d\t",Dist[k]);
        cout << ShortPath[k] << endl;
        
        // 修正当前最短路径及距离
        for (w=0; w<Gra->VertexNum; w++){
            // 如果经过v顶点的路径比现在这条路径的长度短的话就更新
            if (final[w] == 0 && (min+Gra->Edge[k][w]) < Dist[w]){
                Dist[w] = min + Gra->Edge[k][w];
                ShortPath[w] = ShortPath[k];
                ShortPath[w] += Gra->Vertex[w].name;
            }
        }
    }
}

int main()
{
    MGragh g;
    CreateMGragh(&g);
    ShortPathByDijkstra(&g,0);
    return 0;
}

测试用例及结果：