743. Network Delay Time

最新推荐文章于 2021-08-02 01:42:01 发布

Ulricalin

最新推荐文章于 2021-08-02 01:42:01 发布

阅读量239

点赞数

分类专栏： algorithm-design

本文链接：https://blog.csdn.net/Ulricalin/article/details/79124324

版权

algorithm-design 专栏收录该内容

21 篇文章 1 订阅

订阅专栏

本文介绍了一种使用迪杰斯特拉算法解决网络信号传播延迟问题的方法。在一个由N个节点组成的网络中，通过给定的边权重（信号传输时间），从指定的起始节点K出发，计算信号到达所有节点所需的最短时间。如果某些节点无法接收到信号，则返回-1。

摘要由CSDN通过智能技术生成

There are N network nodes, labelled 1 to N.

Given times, a list of travel times as directed edges times[i] = (u, v, w), where u is the source node, v is the target node, and w is the time it takes for a signal to travel from source to target.

Now, we send a signal from a certain node K. How long will it take for all nodes to receive the signal? If it is impossible, return -1.

Note:
N will be in the range [1, 100].
K will be in the range [1, N].
The length of times will be in the range [1, 6000].
All edges times[i] = (u, v, w) will have 1 <= u, v <= N and 1 <= w <= 100.

迪杰斯特拉算法

#define MAX 101
class Solution {
    typedef struct Node {
        int d;
        int u;
        Node(int d1 = 0, int u1 = 0) {
            d = d1;
            u = u1;
        }
        bool operator < (const Node& n1) const {
            return d > n1.d;
        }
        bool operator > (const Node& n1) const {
            return d < n1.d;
        }
    }Node;
public:
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
        vector<Node> G[MAX];
        for (int i = 0; i < times.size(); i++) {
            Node n(times[i][2],times[i][1]);
            G[times[i][0]].push_back(n);
        }

        priority_queue<Node> Q;
        int dis[MAX];
        int pre[MAX];
        bool done[MAX];
        for (int i = 0; i < MAX; i++) {
            dis[i] = INT_MAX;
            done[i] = false;
            pre[i] = -1;
        }
        Node start(0,K);
        Q.push(start);
        dis[K] = 0;
        while (!Q.empty()){
            Node x = Q.top();
            Q.pop();
            if (done[x.u]) continue;
            done[x.u] = true;
            for (int i = 0; i < G[x.u].size(); i++) {
                Node to = G[x.u][i];
                if (dis[to.u] > to.d+dis[x.u]) {
                    dis[to.u] = to.d+dis[x.u];
                    pre[to.u] = x.u;
                    Node n(dis[to.u], to.u);
                    Q.push(n);
                }
            }
        }
        int max = 0;
        for (int i = 1; i <= N; i++) {
            if (dis[i] > max) max = dis[i];
        }
        if (max < INT_MAX) return max;
        return -1;
    }
};