Leetcode743. 网络延迟时间

Every day a Leetcode

题目来源：743. 网络延迟时间

本题需要用到单源最短路径算法 Dijkstra，现在让我们回顾该算法，其主要思想是贪心。

将所有节点分成两类：已确定从起点到当前点的最短路长度的节点，以及未确定从起点到当前点的最短路长度的节点（下面简称「未确定节点」和「已确定节点」）。

每次从「未确定节点」中取一个与起点距离最短的点，将它归类为「已确定节点」，并用它「更新」从起点到其他所有「未确定节点」的距离。直到所有点都被归类为「已确定节点」。

用节点 A「更新」节点 B 的意思是，用起点到节点 A 的最短路长度加上从节点 A 到节点 B 的边的长度，去比较起点到节点 B 的最短路长度，如果前者小于后者，就用前者更新后者。这种操作也被叫做「松弛」。

这里暗含的信息是：每次选择「未确定节点」时，起点到它的最短路径的长度可以被确定。

可以这样理解，因为我们已经用了每一个「已确定节点」更新过了当前节点，无需再次更新（因为一个点不能多次到达）。而当前节点已经是所有「未确定节点」中与起点距离最短的点，不可能被其它「未确定节点」更新。所以当前节点可以被归类为「已确定节点」。

解法1：朴素 Dijkstra 算法

适用于稠密图。

代码：

/*
 * @lc app=leetcode.cn id=743 lang=cpp
 *
 * [743] 网络延迟时间
 */

// @lc code=start
class Solution
{
private:
    const int inf = INT_MAX / 2;

public:
    int networkDelayTime(vector<vector<int>> &times, int n, int k)
    {
        vector<vector<int>> g(n, vector<int>(n, inf));
        for (auto &time : times)
        {
            int u = time[0] - 1, v = time[1] - 1;
            int w = time[2];
            g[u][v] = w;
        }
        // dist[i] 表示点 k 到其他节点的最短距离
        vector<int> dist(n, inf);
        dist[k - 1] = 0;
        vector<int> used(n);
        for (int i = 0; i < n; i++)
        {
            int x = -1;
            for (int y = 0; y < n; y++)
                if (!used[y] && (x == -1 || dist[y] < dist[x]))
                    x = y;
            used[x] = true;
            for (int y = 0; y < n; y++)
                dist[y] = min(dist[y], dist[x] + g[x][y]);
        }

        int ans = *max_element(dist.begin(), dist.end());
        return ans == inf ? -1 : ans;
    }
};
// @lc code=end

结果：

复杂度分析：

时间复杂度：O(n²+m)，其中 n 是节点个数，m 是数组 times 的长度。

空间复杂度：O(n²)，其中 n 是节点个数。

解法2：堆优化 Dijkstra 算法

适用于稀疏图。

寻找最小值的过程可以用一个最小堆来快速完成：

• 一开始把 (dis[k],k) 二元组入堆。
• 当节点 x 首次出堆时，dis[x] 就是写法一中寻找的最小最短路。
• 更新 dis[y] 时，把 (dis[y],y) 二元组入堆。

注意，如果一个节点 x 在出堆前，其最短路长度 dis[x] 被多次更新，那么堆中会有多个重复的 x，并且包含 x 的二元组中的 dis[x] 是互不相同的（因为我们只在找到更小的最短路时才会把二元组入堆）。

所以写法一中的 used 数组可以省去，取而代之的是用出堆的最短路值（记作 dx）与当前的 dis[x] 比较，如果 dx>dis[x] 说明 x 之前出堆过，我们已经更新了 x 的邻居的最短路，所以这次就不用更新了，继续外层循环。

代码：

// 堆优化 Dijkstra（适用于稀疏图）

class Solution
{
private:
    const int inf = INT_MAX / 2;

public:
    int networkDelayTime(vector<vector<int>> &times, int n, int k)
    {
        vector<vector<pair<int, int>>> g(n); // 邻接表
        for (auto &time : times)
        {
            int u = time[0] - 1, v = time[1] - 1;
            int w = time[2];
            g[u].emplace_back(v, w);
        }
        // dist[i] 表示点 k 到其他节点的最短距离
        vector<int> dist(n, inf);
        dist[k - 1] = 0;
        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> pq;
        pq.emplace(0, k - 1);
        while (!pq.empty())
        {
            auto [dx, x] = pq.top();
            pq.pop();
            if (dx > dist[x])
            { // x 之前出堆过
                continue;
            }
            for (auto &[y, d] : g[x])
            {
                int new_dist = dx + d;
                if (new_dist < dist[y])
                {
                    dist[y] = new_dist; // 更新 x 的邻居的最短路
                    pq.emplace(new_dist, y);
                }
            }
        }

        int ans = *max_element(dist.begin(), dist.end());
        return ans == inf ? -1 : ans;
    }
};

结果：

复杂度分析：

时间复杂度：O(mlog⁡m)，其中 m 是数组 times 的长度。值得注意的是，如果输入的是稠密图，本写法的时间复杂度为 O(n²log⁡n)，不如写法一。

空间复杂度：O(m)，其中 m 是数组 times 的长度。