743. 网络延迟时间

 题目：743. 网络延迟时间

题解：

力扣

力扣

class Solution {
private:
    class Node {
    public:
        Node(int dist, int node):_dist(dist), _node(node) {
        }
        int dist() {
            return _dist;
        }
        int node() {
            return _node;
        }
        bool operator < (Node node) const {
            return _dist > node.dist() ? true : false;
        }
    public:
        // 从起始点到当前节点node的最短路径
        int _dist;
        int _node;
    };
public:
    int networkDelayTime(vector<vector<int>>& times, int n, int k) {
        std::unordered_map<int, std::vector<std::pair<int, int>>> graph;
        // 存储图
        for_each(times.begin(), times.end(), [&graph](std::vector<int>& num) {
            graph[num[0]].push_back(std::pair<int, int>(num[1], num[2]));
        });
        // 存储从起点为k到达当前阶段的最短路径
        std::vector<int> dist(n, INT_MAX);
        // 存储当前节点是否已经找到了最短路径
        std::vector<bool> marked(n, false);
        // 目的是找到当前所有路径中的最小值
        std::priority_queue<Node> que;
        // 将起点最短路径设置为0
        dist[k-1] = 0;
        // 压入堆中
        que.push(Node(dist[k-1], k));
        while (!que.empty()) {
            auto f = que.top();
            que.pop();
            /*if (marked[f.node()-1]) {
                continue;
            }*/
            // 标记堆顶节点已经找到最短路径
            marked[f.node()-1] = true;
            // 遍历所有邻居节点
            for (auto& neighboard : graph[f.node()]) {
                // 邻居节点
                int neigh_node = neighboard.first;
                // 到邻居节点的路径长度
                int edge_dist = neighboard.second;
                /*if (marked[neigh_node-1]) {
                    continue;
                }*/
                // 判断是否路径更短
                if (f.dist() + edge_dist < dist[neigh_node-1]) {
                    dist[neigh_node-1] = f.dist() + edge_dist;
                    que.push(Node(dist[neigh_node-1], neigh_node));
                }
            }
        }
        int result = *max_element(dist.begin(), dist.end());
        return result == INT_MAX ? -1 : result;
    }
};

class Solution {
public:
    int networkDelayTime(vector<vector<int>> &times, int n, int k) {
        const int inf = INT_MAX / 2;

        // 邻接矩阵存储边信息
        vector<vector<int>> g(n, vector<int>(n, inf));
        for (auto &t : times) {
            // 边序号从 0 开始
            int x = t[0] - 1, y = t[1] - 1;
            g[x][y] = t[2];
        }

        // 从源点到某点的距离数组
        vector<int> dist(n, inf);
        // 由于从 k 开始，所以该点距离设为 0，也即源点
        dist[k - 1] = 0;

        // 节点是否被更新数组
        vector<bool> 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;
    }
};


作者：已注销
链接：https://leetcode.cn/problems/network-delay-time/solution/gtalgorithm-dan-yuan-zui-duan-lu-chi-tou-w3zc/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int n, int k) {
        std::unordered_map<int, std::vector<std::pair<int, int>>> graph;
        // 存储图
        for_each(times.begin(), times.end(), [&graph](std::vector<int>& num) {
            graph[num[0]].push_back(std::pair<int, int>(num[1], num[2]));
        });
        // 存储从起点为k到达当前阶段的最短路径
        std::vector<int> dist(n, INT_MAX/2);
        dist[k-1] = 0;
        for (int i  = 0; i < n; ++i) {
            for (int j = 1; j <= n; ++j) {
                for (auto& neigh : graph[j]) {
                    int neigh_node = neigh.first-1;
                    int weight = neigh.second;
                    if (dist[j-1] + weight < dist[neigh_node]) {
                        dist[neigh_node] = dist[j-1] + weight;
                    }
                }
            }
        }
        int result = *max_element(dist.begin(), dist.end());
        return result == INT_MAX/2 ? -1 : result;
    }
};