LeetCode#743 Network Delay Time(week19)

week19

题目

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.
原题地址：https://leetcode.com/problems/network-delay-time/description/

代码

struct t {
    int target;
    int dis;
    t(int tar = 0, int d = 0) {
        target = tar;
        dis = d;
    }
};
class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
        vector<vector<t>> map(N + 2);
        for (int i = 0; i < times.size(); ++i) {
            t tmp(times[i][1], times[i][2]);
            map[times[i][0]].push_back(tmp);
        }
        vector<int> dist(N + 1, 9999999);
        vector<int> sets;
        bool* visited = new bool[N + 1];
        for (int i = 0; i < N + 1; ++i) {
            visited[i] = false;
        }
        sets.push_back(K);
        dist[K] = 0;
        visited[K] = true;
        dijkstra(map, sets, dist, N + 1, visited);
        if (sets.size() < N) {
            return -1;
        }
        int m = 0;
        for (int i = 1; i < N + 1; ++i) {
            if (dist[i] > m) {
                m = dist[i];
            }
        }
        return m;
    }
    void dijkstra(vector<vector<t>>& map, vector<int>& sets, vector<int>& dist, int N, bool* visited) {
        if (sets.size() == N) {
            return;
        }
        int update = sets[sets.size() - 1];
        for (int i = 0; i < map[update].size(); ++i) {
            int tar = map[update][i].target;
            if (!visited[tar] && dist[tar] > dist[update] + map[update][i].dis) {
                dist[tar] = dist[update] + map[update][i].dis;
            }
        }
        int pos = 1;
        min(dist, pos, visited);
        if (pos != -1) {
            sets.push_back(pos);
            visited[pos] = true;
            dijkstra(map, sets, dist, N, visited);
        }
    }
    void min(vector<int> nums, int& pos, bool* visited) {
        if (nums.size() <= 1) {
            return;
        }
        int m = 9999999;
        pos = -1;
        for (int i = 1; i < nums.size(); ++i) {
            if (nums[i] < m && visited[i] == false) {
                m = nums[i];
                pos = i;
            }
        }
    }
};