Dijkstra算法

最新推荐文章于 2023-02-09 09:13:27 发布

原创最新推荐文章于 2023-02-09 09:13:27 发布 · 663 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#dijkstra #数据结构

数据结构与算法专栏收录该内容

3 篇文章

订阅专栏

1. 定义

单源点的最短路径问题：给定带权有向图G和源点v，求从v到G中其余各个顶点的最短路径。如何去求得这些最短路径，Dijkstra算法提出了一种按路径长度递增的次序产生最短路径的方案。而对于求解图G中每一对顶点之间的最短路径，其解决方案是重复执行Dijkstra算法n次，这样便可以求解且时间复杂度为O(n^3)。本文仅讨论单源点最短路径问题。

2. 应用

我这个人比较实用主义，一个东西我最先好奇的是它能完成什么工作，其次是再去了解它的原理。Dijkstra算法是求所有最短路径类问题的基本算法。地图导航、12306、还有身边的各种通讯网管布局、包括你们此刻在阅读这篇文章时候个人主机网络节点的选取，都用到了Dijkstra算法。

3.原理

（1）利用n*n阶带权的邻接矩阵arcs来表示带权有向图，arcs[i][j]表示弧<vi, vj>上的权值。若<vi,vj>不存在，则用INFINITE表示。再设S为已找到从v0出发的最短路径的终点的集合，它的初始值是｛v0｝。引入数组D[]，其中的每一个值D[i]分别是v0到vi的最短路径长度。

（2）第一步首先列出所有能从v0直达的顶点，从中选出Min对应的顶点，添加进S集合当中，同时可得对应的D[i]。

（3）接着逐步连通v0与其他顶点，但注意一点，如果有中间节点，则中间节点必须从S集合当中选取。（因为按照S集合特性，每一条最短路径不是弧<v0, vi>本身，就是中间经过S中的顶点vj而到达的vi，这点利用反证法易得）即

D[i]=Min{D[k]|vk属于S};

S = S U {i};

(4)if D[j] + arcs[j][i] < D[i] then D[i] = D[j] + arcs[j][i];

(5)重复第3、4步骤共n-1个顶点即n-1次，结束，D[]即为所求。

4.实战

昨日好友发来一道题，恰好我第一想到的解决方法是用Dijkstra。但想归想，做又是一码事！惭愧的是许久未用早已忘记，而且又虎虎点开了文献二的博客看到了别人家的源码，于是长叹一声默默地放下了手中的辣条。

先给题目--

于是在借鉴文献二的基础下，给出了下面的源码。

==================

15/3/26修正：把源码贴出来后果然有好处，这不就被好友们纠错了:)。下面这个解法没有考虑到最短路径存在多条问题，因此就是WA。但也算是一种思路，参考领会我的意思即可，等过阵子有时间了再想想，先这样。

==================

#include <iostream>
#include <stdio.h>
#include <stack>

using namespace std;

#define MAXLENGTH 100
#define INFINITE 8888
#define NUMBER 10

int matrix[MAXLENGTH][MAXLENGTH];
int shortestlen[MAXLENGTH];
int shortestpath[MAXLENGTH];
int isin[MAXLENGTH];
int ishared[MAXLENGTH];

void Init(int n)
{
    int i, j;
    for (i = 1; i <= n; i++)
        for (j = 1; j <= n; j++)
        {
            if(i == j)
                matrix[i][j] = 0;
            else
                matrix[i][j] = INFINITE;
        }
    for (i = 1; i <= n; i++)
    {
        shortestlen[i] = INFINITE;
        shortestpath[i] = 0;
        isin[i] = 0;
        ishared[i] = 0;
    }
}

int main()
{
    int i, X, Y;
    int temp, temp_i, temp_min;
    int count = 0;
    unsigned int people_count = 0;
    Init(NUMBER);
    while(1)
    {
        scanf("%d, %d", &X, &Y);
        if ( 0 == X || 0 == Y)
            break;
        if (X < Y)
            matrix[X][Y] = 1;
        if (X > Y)      //保证了单向性
            matrix[Y][X] = 1;
    }
    isin[1] = 1;
    shortestpath[1] = 1;
    shortestlen[1] = 0;
    for (i = 2; i <= NUMBER; i++)
    {
        shortestlen[i] = matrix[1][i];
        if (shortestlen[i] != INFINITE)
            shortestpath[i] = 1;
    }
    temp_i = 1;

    while (count < NUMBER - 1)
    {
        temp_min = INFINITE;
        for (i = 1; i <= NUMBER; i++)
        {
            if ((isin[i] == 0) && (shortestlen[i] < temp_min))
            {
                temp_min = shortestlen[i];
                temp_i = i;
            }
        }
        isin[temp_i] = 1;

        for (i = 1; i <= NUMBER; i++)
        {
            if ((isin[i] == 0) && (temp_min + matrix[temp_i][i] < shortestlen[i]))
            {
                shortestlen[i] = temp_min + matrix[temp_i][i];
                shortestpath[i] = temp_i;
            }
        }
        count++;
    }

    stack<int> S;
    for (i = 2; i <= NUMBER; i++)
    {
        temp = i;
        if (0 == shortestpath[temp])
        {
            printf("no path\n");
            continue;
        }
        while (shortestpath[temp] != 1)
        {
            S.push(shortestpath[temp]);
            temp = shortestpath[temp];
        }
        printf("1-->");
        while (!S.empty())
        {
            printf("%d-->", S.top());
            if (!ishared[S.top()])
                ishared[S.top()] = 1;
            S.pop();
        }
        printf("%d min length is %d\n", i, shortestlen[i]);
    }
    for (i = 1; i <= NUMBER; i++)
        if (ishared[i])
            people_count ++;

    printf("======\n%d\n", people_count);
    return 0;
}

运行结果是