50网络延迟时间(743)

作者: Turbo时间限制: 1S章节: DS:图

晚于: 2020-08-05 12:00:00后提交分数乘系数50%

截止日期: 2020-08-12 12:00:00

问题描述 :

有 N 个网络节点，标记为 1 到 N。

给定一个列表 times，表示信号经过有向边的传递时间。 times[i] = (u, v, w)，其中 u 是源节点，v 是目标节点， w 是一个信号从源节点传递到目标节点的时间。

现在，我们从某个节点 K 发出一个信号。需要多久才能使所有节点都收到信号？如果不能使所有节点收到信号，返回 -1。

示例：

输入：times = [[2,1,1],[2,3,1],[3,4,1]], N = 4, K = 2

输出：2

可使用以下main函数：

int main()

{

    int N,M,K;

    vector<vector<int> > times;

    cin>>N>>M>>K;

    int u,v,w;

    for(int i=0; i<M; i++)

    {

        cin>>u>>v>>w;

        vector<int> time;

        time.push_back(u);

        time.push_back(v);

        time.push_back(w);

        times.push_back(time);

    }

    int res=Solution().networkDelayTime(times,N,K);

    cout<<res<<endl;

}

输入说明 :

首先输入网络节点个数N，传递时间列表 times的长度M，起始节点K

然后输入M行，每行三个整数(u, v, w)，其中 u 是源节点，v 是目标节点， w 是一个信号从源节点传递到目标节点的时间。

N 的范围在 [1, 100] 之间。

K 的范围在 [1, N] 之间。

times 的长度M在 [1, 6000] 之间。

所有的边 times[i] = (u, v, w) 都有 1 <= u, v <= N 且 0 <= w <= 100。

输出说明 :

输出一个整数，表示结果。

输入范例 :

4 3 2 2 1 1 2 3 1 3 4 1

输出范例 :

2

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; 
class Solution {
public:
    int flag = 1000;
    vector<vector<int>> G;//图
    int n;
    int root;//源节点
    vector<int> set;//存储已找到最短路径的结点
    vector<int> dis;//存储最短路径
    void dijkstra()
    {
        set[root] = 1;
        dis[root] = 0;
        for (int i = 1; i <= n; i++)
        {
            int k = 0;
            for (int j = 1; j <= n; j++)//找出距离最近的点
                if (!set[j] && (k == 0 || dis[j] < dis[k]))
                    k = j;
            set[k] = 1;//加入集合
            for (int j = 1; j <= n; ++j)//更新
                if (!set[j] && dis[k] + G[k][j] < dis[j])
                    dis[j] = dis[k] + G[k][j];
        }
    }
    int networkDelayTime(vector<vector<int>>& times, int N, int K)
    {
        G.resize(N+1,vector<int>(N+1,flag));
        
        root = K;
        n = N;
        dis.resize(N + 1, flag);//容量加1是因为也要存储本身的节点 
        set.resize(N + 1, 0);
        for (auto temp : times)
        {
            if (temp[0] == K)
                dis[temp[1]] = temp[2];
            G[temp[0]][temp[1]] = temp[2];
        }
        dijkstra();
        int res = *max_element(dis.begin() + 1, dis.end());
        return res == flag ? -1 : res;
    }
};
int main()
{
    int N,M,K;
    vector<vector<int> > times;
    cin>>N>>M>>K;
    int u,v,w;
    for(int i=0; i<M; i++)
    {
        cin>>u>>v>>w;
        vector<int> time;
        time.push_back(u);
        time.push_back(v);
        time.push_back(w);
        times.push_back(time);
    }
    int res=Solution().networkDelayTime(times,N,K);
    cout<<res<<endl;
}