Dijkstra算法思想及实现

Dijkstra算法思想及实现

一、算法思想

    首先，引进一个辅助向量D，它的每个分量D[i]表示当前所找到的从始点v到每个终点vi的最短路径的长度。如D[3]=2表示从始点v到终点3的路径相对最小长度为2。这里强调相对就是说在算法过程中D[i]的值是在不断逼近最终结果但在过程中不一定就等于最短路径长度。它的初始状态为：若从v到vi有弧，则D[i]为弧上的权值；否则置D[i]为∞。显然，长度为 D[j]=Min{D[i] | vi∈V}    的路径就是从v出发的长度最短的一条最短路径。此路径为(v,vj)。

那么，下一条长度次短的最短路径是哪一条呢？假设该次短路径的终点是vk，则可想而知，这条路径或者是(v,vk)，或者是(v,vj,vk)。它的长度或者是从v到vk的弧上的权值，或者是D[j]和从vj到vk的弧上的权值之和。

一般情况下，假设S为已求得最短路径的终点的集合，则可证明：下一条最短路径（设其终点为X）或者是弧(v,x)，或者是中间只经过S中的顶点而最后到达顶点X的路径。因此，下一条长度次短的最短路径的长度必是D[j]=Min{D[i] | vi∈V-S}    其中，D[i]或者是弧(v,vi)上的权值，或者是D[k](vk∈S)和弧(vk,vi)上的权值之和。

二、算法描述

1）arcs[i,j]表示弧<vi,vj>上的权值。若<vi,vj>不存在，则置arcs[i,j]为∞（在本程序中为MAXCOST）。S为已找到从v出发的最短路径的终点的集合，初始状态为空集。那么，从v出发到图上其余各顶点vi可能达到的最短路径长度的初值为D[i]=arcs[Locate Vex(G,v),i] vi∈V
2）选择vj，使得D[j]=Min{D[i] | vi∈V-S}
3）修改从v出发到集合V-S上任一顶点vk可达的最短路径长度。如果D[j]+arcs[j,k]<D[k] 则修改D[k]为D[k]=D[j]+arcs[j,k]。

4）重复2）和3），直到找到目标顶点或遍历所有顶点为止。

 

/*graph.h文件*/
//---------图的数组（邻接矩阵）存储表示----------
#include<stdio.h>
#include <string.h>
#include <stdlib.h>
#define INFINITY  10000        //最大值
#define MAX_VERTEX_NUM 20        //最大顶点个数  
typedef int VRType;        
typedef char VertexType;    
typedef char InfoType;       
typedef enum{DG,DN,UDG,UDN}  GraphKind; //有向图，有向网，无向图，无向网
typedef struct ArcCell
{
    VRType adj;                            //顶点关系类型，对无权图，有1或0表示是否相邻；对带权图，则为权值类型。
    InfoType *info;                        //弧相关信息的指针
}ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

typedef struct
{
    VertexType vexs[MAX_VERTEX_NUM];       //顶点向量
    AdjMatrix  arcs;                       //邻接矩阵
    int        vexnum,arcnum;              //图的当前顶点数和弧数
}mgraph,*MGraph;

int Locate_vexs(MGraph &g,VertexType v)        //定位顶点位置
{
    for (int i=0;i<g->vexnum;i++)
        if (g->vexs[i]==v)
            return i;
    return -1;
}

void Print_mgraph(MGraph &g)        //打印图
{    
    int i;
    printf("邻接矩阵为:\n");
    printf("┏    ");    //五个空格
    for (i=0;i<g->vexnum;i++)
        printf("%c     ",g->vexs[i]);
    printf("\n\n");

    for (i=0;i<g->vexnum;i++)
    {
        printf("%c     ",g->vexs[i]);
        for (int j=0;j<g->vexnum;j++)
        {
            //输出矩阵，并且调整矩阵
            if (g->arcs[i][j].adj>0&&g->arcs[i][j].adj<10)
                printf("%d     ",g->arcs[i][j].adj);
            else if (g->arcs[i][j].adj>9&&g->arcs[i][j].adj<100)
                printf("%d    ",g->arcs[i][j].adj);
            else if (g->arcs[i][j].adj>99&&g->arcs[i][j].adj<1000)
                printf("%d   ",g->arcs[i][j].adj);
            else if (g->arcs[i][j].adj>999&&g->arcs[i][j].adj<10000)
                printf("%d  ",g->arcs[i][j].adj);
            else if(g->arcs[i][j].adj==INFINITY)
                printf("∞    ");
        }
        printf("\n\n");
    }    
}

void Add_vexs(MGraph &g)            //增加顶点
{
    printf("请输入顶点个数：");
    scanf("%d",&g->vexnum);
    getchar();                        //吸收回车符
    printf("请输入顶点字符串序列:");
    for (int i=0;i<g->vexnum;i++)
        scanf("%c",&g->vexs[i]);
}

void Add_arcs(MGraph &g)            //增加边
{
    printf("请输入边的条数:");
    scanf("%d",&g->arcnum);
    VertexType v1,v2;
    int row,col;
    VRType weight;
    printf("请输入权重和对应顶点，以空格隔开：\n");
    for (int i=0;i<g->arcnum;i++)
    {
        scanf("%d %c %c",&weight,&v1,&v2);
        row=Locate_vexs(g,v1);
        col=Locate_vexs(g,v2);
        g->arcs[row][col].adj=weight;
        
    }
}

void Init_graph(MGraph &g)            //初始化图
{
    g=(MGraph)malloc(sizeof(mgraph));
    g->vexnum=0;
    g->arcnum=0;
    for (int i=0;i<MAX_VERTEX_NUM;i++)
        g->vexs[i]='0';
    for (i=0;i<MAX_VERTEX_NUM;i++)
        for (int j=0;j<MAX_VERTEX_NUM;j++)
        {
            g->arcs[i][j].adj=INFINITY;
            g->arcs[i][j].info=NULL;
        }
}

void Create_mgraph(MGraph &g)        //创建图
{
    Add_vexs(g);
    Add_arcs(g);
}

 

/*Dijkstra.cpp文件*/
#include "graph.h"
#define FALSE 0
#define TRUE 1
typedef int PathMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];        //标志走过的路径
typedef int ShortPathTable[MAX_VERTEX_NUM];                    //最短路径长度

void ShortestPath_Dijkstra(MGraph &g,int v0,PathMatrix *P,ShortPathTable *D)
{
    // 用Dijkstra算法求有向网G的v0顶点到其余顶点v的最短路径P[v]及带权长度D[v]。
    // 若P[v][w]为TRUE,则w是从v0到v当前求得最短路径上的顶点。
    // final[v]为TRUE当且仅当v∈S,即已经求得从v0到v的最短路径。
    int v,w,i,j,min;
    int final[MAX_VERTEX_NUM];
    
    for (v=0;v<g->vexnum;++v)
    {
        final[v]=FALSE;
        (*D)[v]=g->arcs[v0][v].adj;
        for (w=0;w<g->vexnum;++w)
            (*P)[v][w]=FALSE;        //设空路径
        if ((*D)[v]<INFINITY)        //v0可以直接到v，但不一定是最近路径
        {
            (*P)[v][v0]=TRUE;        //v0是v0直接到达v的路径的始点
            (*P)[v][v]=TRUE;        //v是v0直接到达v的路径的终点
        }
    }
    
    //S集初始化
    (*D)[v0]=0;
    final[v0]=TRUE;
    //开始主循环，每次求得v0到某个v顶点的最短路径，并加入到S集
    for (i=1;i<g->vexnum;i++)        //其余g.vexnum-1个顶点
    {
        min=INFINITY;                //当前所知离v0顶点的最近距离,赋为∞
        for (w=0;w<g->vexnum;w++)    //求Min{D[i] | vi∈V-S}
        {
            if (!final[w]&&(*D)[w]<min)        //w顶点在V-S集中
            {
                v=w;
                min=(*D)[w];        //w离v0更近                                
            }
        }
        final[v]=TRUE;        //离v0最近的点加入S集
        for (w=0;w<g->vexnum;w++)        //更新当前最短路径及距离
        {
            //修改从v出发到集合V-S上任一顶点w可达的最短路径长度。
            //如果D[j]+arcs[j,k]<D[w] 则修改D[w]为D[w]=D[j]+arcs[j,k]。
            if (!final[w]&&(min+g->arcs[v][w].adj<(*D)[w]))        
            {
                //修改D[w]和P[w],w∈V-S
                (*D)[w]=min+g->arcs[v][w].adj;        //修改当前路径长度
                for (j=0;j<g->vexnum;++j)
                {
                    (*P)[w][j]=(*P)[v][j];        //经过v点的路径直接复制
                    (*P)[w][w]=TRUE;            //
                }
            }
        }
    }
}

int main()
{
    MGraph g;
    Init_graph(g);
    Create_mgraph(g);
    Print_mgraph(g);
    
    int v0,i;
    PathMatrix P;
    ShortPathTable D;        
    printf("输入源点序号,序号由0开始：\n");
    scanf("%d",&v0);
    ShortestPath_Dijkstra(g,v0,&P,&D);
    printf("最短路径数组P[i][j]如下：\n");
    for (i=0;i<g->vexnum;++i)
    {
        for (int j=0;j<g->vexnum;++j)
            printf("%d ",P[i][j]);
        printf("\n");
    }
    printf("源点到各顶点的最短路径长度为:\n");
    for (i=1;i<g->vexnum;++i)
    {
        if (D[i]<INFINITY)
            printf("%c %c %d \n",g->vexs[v0],g->vexs[i],D[i]);
        else
            printf("%c %c ∞\n",g->vexs[v0],g->vexs[i]);
    }
    return 0;
}

 

输入数据：

 

6
123456
10
5 1 2
7 1 4
4 2 3
8 3 1
9 3 6
5 4 3
6 4 6
5 5 4
3 6 1
1 6 5
1

执行结果：

 

转载于:https://www.cnblogs.com/little-sjq/archive/2013/04/12/3016403.html