题目:743. 网络延迟时间
题解:
class Solution {
private:
class Node {
public:
Node(int dist, int node):_dist(dist), _node(node) {
}
int dist() {
return _dist;
}
int node() {
return _node;
}
bool operator < (Node node) const {
return _dist > node.dist() ? true : false;
}
public:
// 从起始点到当前节点node的最短路径
int _dist;
int _node;
};
public:
int networkDelayTime(vector<vector<int>>& times, int n, int k) {
std::unordered_map<int, std::vector<std::pair<int, int>>> graph;
// 存储图
for_each(times.begin(), times.end(), [&graph](std::vector<int>& num) {
graph[num[0]].push_back(std::pair<int, int>(num[1], num[2]));
});
// 存储从起点为k到达当前阶段的最短路径
std::vector<int> dist(n, INT_MAX);
// 存储当前节点是否已经找到了最短路径
std::vector<bool> marked(n, false);
// 目的是找到当前所有路径中的最小值
std::priority_queue<Node> que;
// 将起点最短路径设置为0
dist[k-1] = 0;
// 压入堆中
que.push(Node(dist[k-1], k));
while (!que.empty()) {
auto f = que.top();
que.pop();
/*if (marked[f.node()-1]) {
continue;
}*/
// 标记堆顶节点已经找到最短路径
marked[f.node()-1] = true;
// 遍历所有邻居节点
for (auto& neighboard : graph[f.node()]) {
// 邻居节点
int neigh_node = neighboard.first;
// 到邻居节点的路径长度
int edge_dist = neighboard.second;
/*if (marked[neigh_node-1]) {
continue;
}*/
// 判断是否路径更短
if (f.dist() + edge_dist < dist[neigh_node-1]) {
dist[neigh_node-1] = f.dist() + edge_dist;
que.push(Node(dist[neigh_node-1], neigh_node));
}
}
}
int result = *max_element(dist.begin(), dist.end());
return result == INT_MAX ? -1 : result;
}
};
class Solution {
public:
int networkDelayTime(vector<vector<int>> ×, int n, int k) {
const int inf = INT_MAX / 2;
// 邻接矩阵存储边信息
vector<vector<int>> g(n, vector<int>(n, inf));
for (auto &t : times) {
// 边序号从 0 开始
int x = t[0] - 1, y = t[1] - 1;
g[x][y] = t[2];
}
// 从源点到某点的距离数组
vector<int> dist(n, inf);
// 由于从 k 开始,所以该点距离设为 0,也即源点
dist[k - 1] = 0;
// 节点是否被更新数组
vector<bool> used(n);
for (int i = 0; i < n; ++i) {
// 在还未确定最短路的点中,寻找距离最小的点
int x = -1;
for (int y = 0; y < n; ++y) {
if (!used[y] && (x == -1 || dist[y] < dist[x])) {
x = y;
}
}
// 用该点更新所有其他点的距离
used[x] = true;
for (int y = 0; y < n; ++y) {
dist[y] = min(dist[y], dist[x] + g[x][y]);
}
}
// 找到距离最远的点
int ans = *max_element(dist.begin(), dist.end());
return ans == inf ? -1 : ans;
}
};
作者:已注销
链接:https://leetcode.cn/problems/network-delay-time/solution/gtalgorithm-dan-yuan-zui-duan-lu-chi-tou-w3zc/
来源:力扣(LeetCode)
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
class Solution {
public:
int networkDelayTime(vector<vector<int>>& times, int n, int k) {
std::unordered_map<int, std::vector<std::pair<int, int>>> graph;
// 存储图
for_each(times.begin(), times.end(), [&graph](std::vector<int>& num) {
graph[num[0]].push_back(std::pair<int, int>(num[1], num[2]));
});
// 存储从起点为k到达当前阶段的最短路径
std::vector<int> dist(n, INT_MAX/2);
dist[k-1] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 1; j <= n; ++j) {
for (auto& neigh : graph[j]) {
int neigh_node = neigh.first-1;
int weight = neigh.second;
if (dist[j-1] + weight < dist[neigh_node]) {
dist[neigh_node] = dist[j-1] + weight;
}
}
}
}
int result = *max_element(dist.begin(), dist.end());
return result == INT_MAX/2 ? -1 : result;
}
};