Dijkstra算法详解

Dijkstra算法详解

问题引入

P4779 单源最短路径

给定一个 n个点，m条有向边的带非负权图，请你计算从 s 出发，到每个点的距离。

数据保证你能从 s 出发到任意点。

这基本上是单源最短路径的基本问题

Dijkstra算法介绍

1. Dijkstra 算法基于贪心思想，它只适用于所有边的长度都是非负数的图。当边长z都是非负数时，全局最小值不可能再被其他节点更新，故在第1步中选出的节点 x必然满足:dist[x]已经是起点到 x的最短路径。我们不断选择全局最小值进行标记和扩展，最终可得到起点1到每个节点的最短路径的长度。
2. Dijkstra的时间复杂度上限为 O (n^2) (朴素，未经过优化)，在实际应用中较为稳定；加上堆优化之后更是具有 O ((N+M)logN) 的时间复杂度,在稠密图中有不俗的表现。
3. 在该算法的计算中不能存在负边权，某些算法基于此改进Dijkstra算法，例如：Johnson 算法，复杂度 O(NMlogN)。

Dijkstra算法实现的过程

1. 选取源点S（单源最短路径嘛），初始化dist[s] = 0，其余节点为正无穷大。
2. 找出一个未被标记的、dist[x]最小的节点x，之后标记节点x。
3. 扫描节点的所有出边（x，y，z），若 dist[y] > dist[x] + z 则用 dist[y] = dist[x] + z 更新 dist[y]。
4. 重复以上2、3步骤，直到所有的节点都被标记。

举个例子

在例图中有6个节点（u v w x y z），节点之间的连线表示路径，连线上的数字表示路径花费，路径花费是固定的，假设 u 为源点 s。（queue：u）

step	出发点	u点	v点	w点	x点	y点	z点
初始化	u	0	∞	∞	∞	∞	∞

1.首先我们找到未被标记的点中dist最小的点：u

那么接下来标记点u（弹出u点），更新可以通过u实现更新的点，有x，v，w。

更新一下dist表格的内容：（queue：v，w，x）

step	出发点	u点	v点	w点	x点	y点	z点
1	u	0（标记）	2	5	1	∞	∞

2.我们找到未被标记的点中dist最小的点：x

那么接下来标记点x（弹出x点），更新可以通过x实现更新的点，有u，v，w，y

但其实v和u点并没有更新，因为通过x点后，u到这些点的距离就更远了。

更新一下dist表格的内容：（queue：v，w，y）

step	出发点	u点	v点	w点	x点	y点	z点
1	u	0（标记）	2	5	1	∞	∞
2	x	0（标记）	2	4	1（标记）	2	∞

3.我们找到未被标记的点中dist最小的点：v

那么接下来标记点v（弹出v点），更新可以通过v实现更新的点，有u，x，w

但其实x和u点并没有更新，因为通过v点后，u到这些点的距离就更远了或者并没有改变值。

更新一下dist表格的内容：（queue：w，y）

step	出发点	u点	v点	w点	x点	y点	z点
1	u	0（标记）	2	5	1	∞	∞
2	x	0（标记）	2	4	1（标记）	2	∞
3	v	0（标记）	2（标记）	4	1（标记）	2	∞

4.我们找到未被标记的点中dist最小的点：y

那么接下来标记点y（弹出v点），更新可以通过y实现更新的点，有x，w，z

更新一下dist表格的内容：（queue：w，z）

step	出发点	u点	v点	w点	x点	y点	z点
1	u	0（标记）	2	5	1	∞	∞
2	x	0（标记）	2	4	1（标记）	2	∞
3	v	0（标记）	2（标记）	4	1（标记）	2	∞
4	y	0（标记）	2（标记）	3	1（标记）	2（标记）	4

5.我们找到未被标记的点中dist最小的点：w

那么接下来标记点y（弹出v点），更新可以通过y实现更新的点，有u，x，y，z

更新一下dist表格的内容：（queue：z）

step	出发点	u点	v点	w点	x点	y点	z点
1	u	0（标记）	2	5	1	∞	∞
2	x	0（标记）	2	4	1（标记）	2	∞
3	v	0（标记）	2（标记）	4	1（标记）	2	∞
4	y	0（标记）	2（标记）	3	1（标记）	2（标记）	4
5	w	0（标记）	2（标记）	3（标记）	1（标记）	2（标记）	4

6.我们找到未被标记的点中dist最小的点：z

那么接下来标记点y（弹出v点），更新可以通过y实现更新的点，有w，y

更新一下dist表格的内容：（queue：）

step	出发点	u点	v点	w点	x点	y点	z点
1	u	0（标记）	2	5	1	∞	∞
2	x	0（标记）	2	4	1（标记）	2	∞
3	v	0（标记）	2（标记）	4	1（标记）	2	∞
4	y	0（标记）	2（标记）	3	1（标记）	2（标记）	4
5	w	0（标记）	2（标记）	3（标记）	1（标记）	2（标记）	4
6	z	0（标记）	2（标记）	3（标记）	1（标记）	2（标记）	4（标记）

最终结果：

参考代码：朴素算法

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e6 + 7;
const int inf = 2147483647;
int mp[maxn >> 16][maxn >> 16], dist[maxn >> 16], n, m, s;
bool vis[maxn >> 16];
void dijkstra()
{
    for (int i = 1; i <= n; i++) dist[i] = inf;
    for (int i = 1; i <= n; i++) vis[i] = false;
    dist[s] = 0;
    for (int i = 1; i < n; i++) //重复n - 1次即可
    {
        int x = 0;
        for (int j = 1; j <= n; j++)
            if (!vis[j] && (x == 0 || dist[j] < dist[x]))
                x = j;
        if (x == 0) break;
        vis[x] = true;
        for (int y = 1; y <= n; y++)
            dist[y] = min(dist[y], dist[x] + mp[x][y]);
    }
}
int main()
{
    cin >> n >> m >> s;
    memset(mp, 0x3f3f3f, sizeof(mp));
    for (int i = 1; i <= m; i++)
    {
        int x, y, z;
        cin >> x >> y >> z;
        mp[x][y] = min(mp[x][y], z);
    }
    dijkstra();
    for (int i = 1; i <= n; i++)
        cout << dist[i] << " ";
    cout << endl;
    return 0;
}

参考代码：堆优化，涉及链式前向星

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e6 + 7;
const int inf = (1 << 31) - 1;
int n, m, s, tot = 1;
int head[maxn], ver[maxn], edge[maxn], nxt[maxn], dist[maxn];
bool vis[maxn];
struct Node 
{
    int dis, pos;
    bool operator < (const Node &x) const 
    {
        return dis > x.dis;
    }
};
priority_queue<Node> q;
void addE(int u, int v, int w)
{
    ver[++tot] = v;
    edge[tot] = w;
    nxt[tot] = head[u];
    head[u] = tot;
}
void dijkstra()
{
    for (int i = 1; i <= n; i++)
    {
        dist[i] = inf;
        vis[i] = false;
    }
    dist[s] = 0;
    q.push({0, s});
    while (q.size())
    {
        int x = q.top().pos;
        q.pop();
        if (vis[x])
            continue;
        vis[x] = true;
        for (int i = head[x]; i; i = nxt[i])
        {
            int y = ver[i], z = edge[i];
            if (dist[y] > dist[x] + z)
            {
                dist[y] = dist[x] + z;
                q.push({dist[y], y});
            }
        }
    }

}
int main()
{
    scanf("%d %d %d", &n, &m, &s);
    for (int i = 1; i <= m; i++)
    {
        int x, y, z;
        scanf("%d %d %d", &x, &y, &z);
        addE(x, y, z);
    }
    dijkstra();
    for (int i = 1; i <= n; i++)
        cout << dist[i] << " ";
    return 0;
}

参考来源：

1. 《算法进阶指南（李煜东）》