算法学习记录-图——最短路径之Dijkstra算法

在网图中，最短路径的概论：

两顶点之间经过的边上权值之和最少的路径，并且我们称路径上的第一个顶点是源点，最后一个顶点是终点。

*上面的解释：

这个算法是通过为每个顶点 v 保留目前为止所找到的从s到v的最短路径来工作的。

初始时，原点 s 的路径长度值被赋为 0 （d[s] = 0），若存在能直接到达的边（s,m），则把d[m]设为w（s,m）,同时把所有其他（s不能直接到达的）顶点的路径长度设为无穷大，即表示我们不知道任何通向这些顶点的路径（对于 V 中所有顶点 v除 s 和上述 m 外 d[v] = ∞）。

当算法退出时，d[v] 中存储的便是从 s 到 v 的最短路径，或者如果路径不存在的话是无穷大。

Dijkstra 算法的基础操作是边的拓展：如果存在一条从 u 到 v 的边，那么从 s 到 v 的最短路径可以通过将边（u, v）添加到尾部来拓展一条从 s 到 u 的路径。

这条路径的长度是 d[u] + w(u, v)。如果这个值比目前已知的 d[v] 的值要小，我们可以用新值来替代当前 d[v] 中的值。

拓展边的操作一直运行到所有的 d[v] 都代表从 s 到 v 最短路径的花费。

这个算法经过组织因而当 d[u] 达到它最终的值的时候每条边（u, v）都只被拓展一次。

算法维护两个顶点集 S 和 Q。集合 S 保留了我们已知的所有 d[v] 的值已经是最短路径的值顶点，而集合 Q 则保留其他所有顶点。

集合S初始状态为空，而后每一步都有一个顶点从 Q 移动到 S。

这个被选择的顶点是 Q 中拥有最小的 d[u] 值的顶点。当一个顶点 u 从 Q 中转移到了 S 中，算法对每条外接边 (u, v) 进行拓展。

后来我根据自己的理解，该算法基本可以分为这样几个步骤：

我用网上的一个图为例，说明该算法的执行过程。

下面来看代码：

void Dijkstra(MGraph g,int Vs,int *path,int *Dest)
{
    int i,j,k;
    EdgeType min;
    int isshort[MAXVEX];

    //初始化path前驱，Vs起始点到其他点的距离。
    for (i =;i<g.numVexs;i++)
    {
        isshort[i]=;
        path[i]=;
        Dest[i]=g.Mat[Vs][i];
    }

    //Vs选入isshort中
    isshort[Vs]=;
    //Vs到Vs的距离为0
    Dest[Vs]=;

    for (i=;i<g.numVexs;i++)
    {
        //寻找当前最小的路径
        min = IFY;
        for (j=;j<g.numVexs;j++)
        {
            if (isshort[j] ==  && Dest[j] < min)
            {
                min = Dest[j];
                k=j;
            }
        }
        //把最小的标号记录，且该下标的顶点进入isshort
        isshort[k]=;

        //在k为下标的顶点时候，寻找以k为起点，和k相连且没有归入到isshort中的点，
        //Dest中存放的是 各个顶点到Vs点的最短距离。
        //此时，如果通过K点到达各个点的距离还要小，则更新Dest数组。
        for (j=;j<g.numVexs;j++)
        {

            if (isshort[j] ==  && ((min + g.Mat[k][j])  < Dest[j]) )
            {
                Dest[j]=min+g.Mat[k][j];
                path[j]=k;
            }
        }
    }
}

代码中的第一个for循环再第一幅图中表示。第二个for循环，依次为标号为1,。。。9的图。可以对着看。

完整代码：

// grp-dijkstra.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <stdlib.h>
#include <string.h>

#define MAXVEX 100
#define IFY 65535

typedef char VertexType;
typedef int  EdgeType;

bool g_visited[MAXVEX];

VertexType g_init_vexs[MAXVEX] = {'A','B','C','D','E','F','G','H','I'};

EdgeType g_init_edges[MAXVEX][MAXVEX] = {
    {,,,IFY,IFY,IFY,IFY,IFY,IFY},    //'A'
    {,,,,,IFY,IFY,IFY,IFY},  //'B'
    {,,,IFY,,,IFY,IFY,IFY},//'C'
    {IFY,,IFY,,,IFY,,IFY,IFY},//'D'
    {IFY,,,,,,,,IFY},    //'E'
    {IFY,IFY,,IFY,,,IFY,,IFY},    //'F'
    {IFY,IFY,IFY,,,IFY,,,},    //'G'
    {IFY,IFY,IFY,IFY,,,,,},    //'H'
    {IFY,IFY,IFY,IFY,IFY,IFY,,,},    //'I'
};

//静态图-邻接矩阵
typedef struct {
    VertexType vexs[MAXVEX];
    EdgeType Mat[MAXVEX][MAXVEX];
    int numVexs,numEdges;
}MGraph;

//====================================================================
//打印矩阵
void prt_maxtix(EdgeType *p,int vexs)
{
    int i,j;
    for (i=;i<vexs;i++)
    {
        printf("\t");
        for (j=;j<vexs;j++)
        {
            if( (*(p + MAXVEX*i + j)) == IFY)
            {
                printf("  $ ");
            }
            else
            {
                printf(" %2d ", *(p + MAXVEX*i + j));
            }
        }
        printf("\n");
    }
}

//check the number of vextex
int getVexNum(VertexType *vexs)
{
    VertexType *pos = vexs;
    int cnt=;
    while(*pos <= 'Z' && *pos >= 'A')
    {
        cnt++;
        pos++;
    }
    return cnt;
}

bool checkMat(EdgeType *p,VertexType numvex)
{
    int i,j;
    for (i=;i<numvex;i++)
    {
        for(j=i+;j<numvex;j++)
        {
            //printf("[%d][%d] = %d\t",i,j,*(p + MAXVEX*i + j));
            //printf("[%d][%d] = %d\n",j,i,*(p + MAXVEX*j + i));
            if (*(p + MAXVEX*i + j) != *(p + MAXVEX*j +i) )
            {
                printf("ERROR:Mat[%d][%d] or Mat[%d][%d] not equal!\n",i,j,j,i);
                return false;
            }
        }
    }
    return true;
}

void init_Grp(MGraph *g,VertexType *v,EdgeType *p)
{
    int i,j;
    // init vex num
    (*g).numVexs = getVexNum(v);

    //init vexter
    for (i=;i<(*g).numVexs;i++)
    {
        (*g).vexs[i]=*v;
        v++;
    }

    //init Mat
    for (i=;i<(*g).numVexs;i++)
    {
        for (j=;j<(*g).numVexs;j++)
        {
            (*g).Mat[i][j] = *(p + MAXVEX*i + j);
        }
    }
    if(checkMat(&((*g).Mat[][]),(*g).numVexs) == false)
    {
        printf("init error!\n");
        getchar();
        exit();
    }
}

void Dijkstra(MGraph g,int Vs,int *path,int *Dest)
{
    int i,j,k;
    EdgeType min;
    int isshort[MAXVEX];

    //初始化path前驱，Vs起始点到其他点的距离。
    for (i =;i<g.numVexs;i++)
    {
        isshort[i]=;
        path[i]=;
        Dest[i]=g.Mat[Vs][i];
    }

    //Vs选入isshort中
    isshort[Vs]=;
    //Vs到Vs的距离为0
    Dest[Vs]=;

    for (i=;i<g.numVexs;i++)
    {
        //寻找当前最小的路径
        min = IFY;
        for (j=;j<g.numVexs;j++)
        {
            if (isshort[j] ==  && Dest[j] < min)
            {
                min = Dest[j];
                k=j;
            }
        }
        //把最小的标号记录，且该下标的顶点进入isshort
        isshort[k]=;

        //在k为下标的顶点时候，寻找以k为起点，和k相连且没有归入到isshort中的点，
        //Dest中存放的是 各个顶点到Vs点的最短距离。
        //此时，如果通过K点到达各个点的距离还要小，则更新Dest数组。
        for (j=;j<g.numVexs;j++)
        {

            if (isshort[j] ==  && ((min + g.Mat[k][j])  < Dest[j]) )
            {
                Dest[j]=min+g.Mat[k][j];
                path[j]=k;
            }
        }
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    MGraph grp;
    EdgeType Dest[MAXVEX];
    EdgeType Path[MAXVEX];

    EdgeType edgeDest[MAXVEX][MAXVEX];
    EdgeType edgePath[MAXVEX][MAXVEX];

    int i;

    init_Grp(&grp,g_init_vexs,&g_init_edges[][]);
    //prt_maxtix(&grp.Mat[0][0],grp.numVexs);
    printf("Dijkstr start!\n");
    for (i=;i<grp.numVexs;i++)
    {
        Dijkstra(grp,i,Path,Dest);
        memcpy(edgeDest[i],Dest,grp.numVexs*sizeof(Dest[]));
        memcpy(edgePath[i],Path,grp.numVexs*sizeof(Path[]));

        memset(Dest,,grp.numVexs*sizeof(Dest[]));
        memset(Path,,grp.numVexs*sizeof(Path[]));
    }
    //Dijkstra(grp,0,Path,Dest);
    printf("Dest vs to ve :\n");
    prt_maxtix(&edgeDest[][],grp.numVexs);

    printf("Path matix :\n");
    prt_maxtix(&edgePath[][],grp.numVexs);

    printf("finish\n");
    getchar();
    return ;
}

结果：

这个结果的意思是：

Dest vs to ve：

每一行为一个单独，比如第一行，表示V0到Vx的距离。与我们之前分析的第10幅图一样。

从这个表里面可以看出，任何一个点到另一个点的最短距离。

Path Matix：

最短路径所经过的点，对照第10幅图来看，就知道怎么线索路径，反一下就知道路径点。

这个可以看出，在主程序里面一个for

在Dijkstra中，for 中嵌套for，时间复杂度为O（N³）。（简化的粗估计）

对于大量的点，该方法效率会非常的低。因为对于每一个点，它都将遍历图中的其他每一个点。