代码片段_震惊，最短路算法！！！！

系列文章目录

单源最短路径（1）：Dijkstra 算法
单源最短路径（2）：Bellman_Ford 算法
 单源最短路径（3）：SPFA 算法
 单源最短路径（4）：总结

一：背景展开目录

Dijkstra 算法（中文名：迪杰斯特拉算法）是由荷兰计算机科学家 Edsger Wybe Dijkstra 提出。该算法常用于路由算法或者作为其他图算法的一个子模块。举例来说，如果图中的顶点表示城市，而边上的权重表示城市间开车行经的距离，该算法可以用来找到两个城市之间的最短路径。

二：算法过程展开目录

我们用一个例子来具体说明迪杰斯特拉算法的流程。

定义源点为 0，dist[i]为源点 0 到顶点 i 的最短路径。其过程描述如下：

步骤	dist[1]	dist[2]	dist[3]	dist[4]	已找到的集合
第 1 步	8	1	2	+∞	{2}
第 2 步	8	×	2	4	{2, 3}
第 3 步	5	×	×	4	{2, 3, 4}
第 4 步	5	×	×	×	{2, 3, 4, 1}
第 5 步	×	×	×	×	{2, 3, 4, 1}

第 1 步：从源点 0 开始，找到与其邻接的点：1，2，3，更新dist[]数组，因 0 不与 4 邻接，故dist[4]为正无穷。在dist[]中找到最小值，其顶点为 2，即此时已找到 0 到 2 的最短路。

第 2 步：从 2 开始，继续更新dist[]数组：2 与 1 不邻接，不更新；2 与 3 邻接，因0→2→3比dist[3]大，故不更新dist[3] ；2 与 4 邻接，因0→2→4比dist[4]小，故更新dist[4]为 4。在dist[]中找到最小值，其顶点为 3，即此时又找到 0 到 3 的最短路。

第 3 步：从 3 开始，继续更新dist[]数组：3 与 1 邻接，因0→3→1比dist[1]小，更新dist[1]为 5；3 与 4 邻接，因0→3→4比dist[4]大，故不更新。在dist[]中找到最小值，其顶点为 4，即此时又找到 0 到 4 的最短路。

第 4 步：从 4 开始，继续更新dist[]数组：4 与 1 不邻接，不更新。在dist[]中找到最小值，其顶点为 1，即此时又找到 0 到 1 的最短路。

第 5 步：所有点都已找到，停止。

对于上述步骤，你可能存在以下的疑问：

若 A 作为源点，与其邻接的只有 B，C，D 三点，其dist[]最小时顶点为 C，即就可以确定A→C为 A 到 C 的最短路。但是我们存在疑问的是：是否还存在另一条路径使 A 到 C 的距离更小？ 用反证法证明。

假设存在如上图的红色虚线路径，使A→D→C的距离更小，那么A→D作为A→D→C的子路径，其距离也比A→C小，这与前面所述 “dist[]最小时顶点为 C” 矛盾，故假设不成立。因此这个疑问不存在。

根据上面的证明，我们可以推断出，Dijkstra 每次循环都可以确定一个顶点的最短路径，故程序需要循环 n-1 次。

三：完整代码展开目录

/**
*
* author 刘毅（Limer）
* date   2017-05-17
* mode   C++
*/
#include<iostream>
using namespace std;

int matrix[100][100];  //邻接矩阵
bool visited[100];     //标记数组
int dist[100];         //源点到顶点i的最短距离
int path[100];         //记录最短路的路径
int source;            //源点
int vertex_num;        //顶点数
int arc_num;           //弧数

void Dijkstra(int source)
{
    memset(visited, 0, sizeof(visited));  //初始化标记数组
    visited[source] = true;
    for (int i = 0; i < vertex_num; i++)
    {
        dist[i] = matrix[source][i];
        path[i] = source;
    }

    int min_cost;        //权值最小
    int min_cost_index;  //权值最小的下标
    for (int i = 1; i < vertex_num; i++)  //找到源点到另外vertex_num-1个点的最短路径
    {
        min_cost = INT_MAX;
        for (int j = 0; j < vertex_num; j++)
        {
            if (visited[j] == false && dist[j] < min_cost)  //找到权值最小
            {
                min_cost = dist[j];
                min_cost_index = j;
            }
        }

        visited[min_cost_index] = true;  //该点已找到，进行标记

        for (int j = 0; j < vertex_num; j++)  //更新dist数组
        {
            if (visited[j] == false && 
                matrix[min_cost_index][j] != INT_MAX &&  //确保两点之间有弧
                matrix[min_cost_index][j] + min_cost < dist[j])
            {
                dist[j] = matrix[min_cost_index][j] + min_cost;
                path[j] = min_cost_index;
            }
        }
    }
}

int main()
{
    cout << "请输入图的顶点数（<100）：";
    cin >> vertex_num;
    cout << "请输入图的弧数：";
    cin >> arc_num;

    for (int i = 0; i < vertex_num; i++)
        for (int j = 0; j < vertex_num; j++)
            matrix[i][j] = (i != j) ? INT_MAX : 0;  //初始化matrix数组

    cout << "请输入弧的信息：\n";
    int u, v, w;
    for (int i = 0; i < arc_num; i++)
    {
        cin >> u >> v >> w;
        matrix[u][v] = matrix[v][u] = w;
    }

    cout << "请输入源点（<" << vertex_num << "）：";
    cin >> source;
    Dijkstra(source);

    for (int i = 0; i < vertex_num; i++)
    {
        if (i != source)
        {
            cout << source << "到" << i << "最短距离是：" << dist[i] << "，路径是：" << i;
            int t = path[i];
            while (t != source)
            {
                cout << "--" << t;
                t = path[t];
            }
            cout << "--" << source << endl;
        }
    }

    return 0;
}

输入数据，结果为：

四：时间复杂度展开目录

设图的边数为 m，顶点数为 n。

Dijkstra 算法最简单的实现方法是用一个数组来存储所有顶点的dist[]（即本程序采用的策略），所以搜索dist[]中最小元素的运算需要线性搜索 $O (n)$

对于边数远少于 $n^{2}$

关于 $O ((m + n) l o g n)$

把dist[]数组调整成最小堆，需要 $O (n)$
因为是最小堆，所以每次取出最小值只需 $O (1)$
我们需要 n-1 次操作才可以找出剩下的 n-1 个点，在这期间，大约需要访问 m 次边，每次访问都可能造成dist[]的改变，因此还需要 $O (l o g n)$

综上所述：总的时间复杂度为： $O (n) + O (n l o g n) + O (m l o g n) = O ((m + n) l o g n)$

最后简单说下 Dijkstra 优化时二叉堆的两种实现方式：

优先队列，把每个顶点的序号和其dist[]压在一个结构体再放进队列里；
自己建一个小顶堆heap[]，存储顶点序号，再用一个数组pos[]记录第 i 个顶点在堆中的位置。

相比之下，前者的编码难度较低，因此在平时编程甚至算法竞赛中，都是首选。

五：该算法的缺陷展开目录

Dijkstra 算法有个巨大的缺陷，请考虑下面这幅图：

u→v间存在一条负权回路（所谓的负权回路，维基和百科并未收录其名词，但从网上的一致态度来看，其含义为：如果存在一个环（从某个点出发又回到自己的路径），而且这个环上所有权值之和是负数，那这就是一个负权环，也叫负权回路），那么只要无限次地走这条负权回路，便可以无限制地减少它的最短路径权值，这就变相地说明最短路径不存在。一个不存在最短路径的图，Dijkstra 算法无法检测出这个问题，其最后求解的dist[]也是错的。

那么对于上述的 “一个不存在最短路径的图”，我们该用什么方法来解决呢？请接着看本系列第二篇文章。