60 lines
1.7 KiB
C++
60 lines
1.7 KiB
C++
#include <vector>
|
|
#include <tuple>
|
|
#include <queue>
|
|
#include <iostream>
|
|
|
|
/**
|
|
* 743. Network Delay Time
|
|
* You are given a network of n nodes, labeled from 1 to n. You are also given times, a list of travel times as directed edges times[i] = (ui, vi, wi), where ui is the source node, vi is the target node, and wi is the time it takes for a signal to travel from source to target.
|
|
* We will send a signal from a given node k. Return the time it takes for all the n nodes to receive the signal. If it is impossible for all the n nodes to receive the signal, return -1.
|
|
*
|
|
* Comment: This is Dijkstra's algorithm.
|
|
*/
|
|
|
|
class Solution {
|
|
public:
|
|
static int networkDelayTime(const std::vector<std::vector<int>>& times, int n, int k) {
|
|
const int edgeCnt = times.size();
|
|
std::vector<std::tuple<int, int, int>> edges;
|
|
std::vector<std::vector<int>> G(n);
|
|
edges.reserve(edgeCnt);
|
|
for (int i = 0; i < edgeCnt; ++i) {
|
|
edges.emplace_back(times[i][0] - 1, times[i][1] - 1, times[i][2]);
|
|
G[times[i][0] - 1].push_back(i);
|
|
}
|
|
|
|
std::vector<int> dist(n, 0x6FFFFFFF);
|
|
std::vector<bool> vis(n);
|
|
--k;
|
|
|
|
// pair<dist, idx>
|
|
std::priority_queue<std::pair<int, int>, std::vector<std::pair<int, int>>, std::greater<>> q;
|
|
q.push({0, k});
|
|
dist[k] = 0;
|
|
while (!q.empty()) {
|
|
const auto [len, node] = q.top();
|
|
q.pop();
|
|
|
|
if (vis[node])
|
|
continue;
|
|
vis[node] = true;
|
|
|
|
for (int eId : G[node]) {
|
|
const auto [f, t, d] = edges[eId];
|
|
if (dist[t] <= dist[node] + d)
|
|
continue;
|
|
dist[t] = dist[node] + d;
|
|
q.push({dist[t], t});
|
|
}
|
|
}
|
|
|
|
int ret = *std::max_element(dist.begin(), dist.end());
|
|
return ret == 0x6FFFFFFF ? -1 : ret;
|
|
}
|
|
};
|
|
|
|
int main() {
|
|
std::cout << Solution::networkDelayTime({{2,1,1},{2,3,1},{3,4,1}}, 4, 2);
|
|
return 0;
|
|
}
|