单源最短路径：Dijkstra算法

单源最短路径：Dijkstra算法

概览

Dijkstra算法（迪杰斯特拉算法）是由荷兰计算机科学家Edsger Wybe Dijkstra提出，是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。
注意该算法要求图中不存在负权边。

问题

在带权有向图G=(V,A)中，假设每条弧A[i]的长度为w[i]，找到由顶点V0到其余各点的最短路径。

算法描述

算法思想

设G=(V,A)是一个带权有向图，把图中顶点集合V分成两组，第一组为已求出最短路径的顶点集合（用S表示，初始时S中只有一个源点V0，以后每求得一条最短路径 , 就将加入到集合S中，直到全部顶点都加入到S中，算法就结束了），第二组为其余未确定最短路径的顶点集合（用U表示），按最短路径长度的递增次序依次把第二组的顶点加入S中。在加入的过程中，总保持从源点V0到S中各顶点的最短路径长度不大于从源点V0到U中任何顶点的最短路径长度。此外，每个顶点对应一个距离，源点V0到S中的点的距离dist[i]就是从源点V0到此顶点的最短路径长度，源点V0到U中的点的距离dist[i]，是从V0到此顶点的，只包括S中的顶点为中间顶点的当前最短路径长度。

算法过程

1. 初始时，S只包含源点V0，即S={V0}，V0距源点V0的距离为0。U包含除V0外的其他顶点。若U中某个顶点u是V0的出边邻接点，则V0到u的距离为V0到u的弧的弧长，若u不是V0的出边邻接点，则u到V0的距离为∞。将V0作为基点。
2. 在U中选出u0，使基点到u0的距离最小，将其加入S中。此时V0到u0的距离就是V0到u0的最短路径的长度。
3. 以u0为基点，用从V0到u0的距离，对U中是u0的出边邻接点的所有点ux进行松弛操作，即如果源点V0经过u0到达ux的距离比原来记录的V0到ux的距离小，则用经过u0到达ux的距离更新V0到ux的距离。
4. 重复2和3，直到所有顶点都在S中。

动画演示

（动画来源）

反证

是否存在另一条路径使得A到C的距离更小？用反证法证明：
假设存在如上图的红色虚线路径，使得A->D->C的距离更小，那么A->D作为A->D->C的一部分，其距离也比A->C小，这与C是U中到V0距离最小的点相矛盾，故假设不成立。
根据上面的证明，我们可以推断出，Dijkstra算法每次循环都可以确定一个顶点的最短路径，故需要循环n-1次。

程序代码

/*
FILE:dijkstra.cpp
LANG:C++
*/
#include <iostream>
#include <cstring>
using namespace std;

const int node_num = 100;       //定义最大顶点数
const int INF = 2147483647;     //定义无穷
int matrix[node_num][node_num]; //邻接矩阵
int dist[node_num];             //记录源点到各个顶点的距离
int path[node_num];             //记录前驱顶点
bool vis[node_num];             //标记顶点是否在集合S中
int v_num, a_num;               //记录顶点数和弧的数量

void dijkstra(const int);

int main()
{
    cout << "v_num:";
    cin >> v_num;
    cout << "a_num:";
    cin >> a_num;

    for (int i = 0; i < v_num; ++i)
    {
        for (int j = 0; j < v_num; ++j)
        {
            matrix[i][j] = ((i != j) ? INF : 0);    //初始化邻接矩阵
        }
    }

    int u, v, w;
    for (int i = 0; i < a_num; ++i)
    {
        cin >> u >> v >> w;
        matrix[u][v] = matrix[v][u] = w;    //示例为一个无向图
    }

    int src;
    cout << "source:";
    cin >> src;    //输入源点

    dijkstra(src);

    for (int i = 0; i < v_num; ++i)
    {
        if (i != src)
        {
            cout << src << "->" << i << ":" << dist[i] << ":" << i;
            int t = path[i];
            while (t != src)
            {
                cout << "-" << t;
                t = path[t];
            }
            cout << "-" << src << endl;    //路径是按倒序输出的
        }
    }
    return 0;
}

void dijkstra(const int src)
{
    memset(vis, false, sizeof(vis));    //初始化集合S的标记
    vis[src] = true;    //源点进入集合S
    for (int i = 0; i < v_num; ++i)
    {
        dist[i] = matrix[src][i];    //初始化从源点到各点的距离
        path[i] = src;    //初始化前驱顶点
    }
    int min_cost, min_cost_index;    //记录源点到U中各个顶点距离的最小值和顶点编号
    for (int i = 1; i < v_num; ++i)
    {
        min_cost = INF;
        for (int j = 0; j < v_num; ++j)    //找距离的最小值和对应的点u0
        {
            if (!vis[j] && dist[j] < min_cost)
            {
                min_cost = dist[j];
                min_cost_index = j;
            }
        }
        vis[min_cost_index] = true;    //u0进入集合S
        for (int j = 0; j < v_num; ++j)
        {
            if (!vis[j] && matrix[min_cost_index][j] != INF && min_cost + matrix[min_cost_index][j] < dist[j])    //如果U中顶点ux是u0的出边邻接点且源点经过u0到达ux的距离比原来记录的源点到ux的距离小
            {
                dist[j] = min_cost + matrix[min_cost_index][j];    //执行松弛操作
                path[j] = min_cost_index;    //更新前驱顶点
            }
        }
    }
    return;
}

示例图：

运行结果：

参考

1. 最短路径—Dijkstra算法和Floyd算法
2. 单源最短路径（1）：Dijkstra 算法