743-Network Delay Time

类别：graph

难度：medium

题目描述

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:

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

算法分析

（1）首先，根据题目所给的信息，存储每个节点的后继节点集合和相邻两个节点之间所需要的时间（二维数组）

（2）用队列，BFS实现Dijkstra算法，找到从节点K到每个节点的最短路径

（3）对于队列中的队头节点，遍历它的所有后继节点，并且判断经过当前节点到达其后继节点是否能够使得后继节点的最短路径发生改变，如果是，更新其后继节点的最短等待时间，如果其后继节点没有访问过，则将其后继节点加到队列中

（4）最后，对从源节点到所有节点的最短路径进行比较，取最大值，即为所求。

代码实现

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
        vector< unordered_set<int> > adj(N + 1);
        vector< vector<int> > weight(N+1, vector<int> (N+1,0));
        int tNum = times.size();
        // 得到相邻的节点集合以及时间消耗 
        for (int i = 0; i < tNum; ++i) {
        	adj[times[i][0]].insert(times[i][1]);
        	weight[times[i][0]][times[i][1]] = times[i][2];
		}
		//  dijkstra算法
		vector<int> wait(N + 1, INT_MAX);
		vector<bool> visited(N + 1, false);
		queue<int> que;
		que.push(K);
		wait[K] = 0;
		visited[K] = true;
		int node = 0;
		while (!que.empty()) {
			node = que.front();
			que.pop();
			for (auto neighbor : adj[node]) {
				if (wait[neighbor] > wait[node] + weight[node][neighbor]) {
					if (visited[neighbor] == false) {
						que.push(neighbor);
                        visited[neighbor == true];
                    }
					wait[neighbor] = wait[node] + weight[node][neighbor];
				}
			}
		}
		int maxTime = 0;
		for (int i = 1; i <= N; ++i) {
			maxTime = max(maxTime, wait[i]);
		}
		if (maxTime == INT_MAX) return -1;
		return maxTime;
    }
};