LeetCode743 网络延迟时间

LeetCode743 网络延迟时间

题目

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

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

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

输入：times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2
输出：2

解题思路

我们使用 Dijkstra’s 算法找到从源节点到所有节点的最短路径，可以点击这个Dijkstra算法详解了解更多详细信息。Dijkstra’s 算法是每次扩展一个距离最短的点，更新与其相邻点的距离。

class Solution {
public:
	vector<int> visited;
	vector<vector<int>> graph;
	vector<int> distance;

	//weight存储节点之间的权重 eg:[[2,1,1],[2,3,1],[3,4,1]]，第一个元素意思是2节点指向1节点，而且这条边的权值为1（节点从0开始）
	//n是节点数
	//k是要判断第k个节点（节点从0开始）
	int networkDelayTime(vector<vector<int>>& weight, int n, int k) {
		graph.resize(n + 1, vector<int>(n + 1, -1));
		distance.resize(n + 1, -1);
		distance[k] = 0;
		visited.resize(n + 1, 0);
		for (int i = 0; i < weight.size(); i++)
		{
			int one = weight[i][0];//有向边的尾部
			int two = weight[i][1];//有向边的头部，即one->two
			int thisweight = weight[i][2];//这条有向边的权值
			graph[one][two] = thisweight;
		}
		for (int i = 0; i < graph[k].size(); i++)
		{
			
			distance[i] = graph[k][i];
		}
		visited[k] = - 1;

		for (int i = 1; i <= n; i++)
		{
			int mindis = (1 << 30) - 1;
			int minindex = 0;
			for (int j = 1; j <= n ; j++)
			{
				if (visited[j] == 0 && distance[j] < mindis && distance[j] >= 0)
				{
					mindis = distance[j];
					minindex = j;
				}
			}
			visited[minindex] = -1; 
			for (int j = 1; j <= n; j++)
			{
				if (graph[minindex][j] >= 0 && visited[j] == 0)
				{
					int thisdistance = distance[minindex] + graph[minindex][j];
					if (distance[j] > thisdistance || distance[j] == -1)
					{
						distance[j] = thisdistance;
					}
				}
			}
		}
		int res = 0;
		for (int i = 1; i <= n ; i++)
		{
			if (distance[i] == -1 && i!=k)
				return -1;
			res = max(res, distance[i]);
		}
		return res;
	}
};