743. 网络延迟时间
有 n 个网络节点,标记为 1 到 n。
给你一个列表 times,表示信号经过 有向 边的传递时间。 times[i] = (ui, vi, wi),其中 ui 是源节点,vi 是目标节点, wi 是一个信号从源节点传递到目标节点的时间。
现在,从某个节点 K 发出一个信号。需要多久才能使所有节点都收到信号?如果不能使所有节点收到信号,返回 -1 。
示例 1:
输入:times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2
输出:2
示例 2:
输入:times = [[1,2,1]], n = 2, k = 1
输出:1
示例 3:
输入:times = [[1,2,1]], n = 2, k = 2
输出:-1
提示:
1 <= k <= n <= 100
1 <= times.length <= 6000
times[i].length == 3
1 <= ui, vi <= n
ui != vi
0 <= wi <= 100
所有 (ui, vi) 对都 互不相同(即,不含重复边)
题解:
方法一:Floyd算法
这题首先第一时间想到的算法就是DFS
,通过将每一种方式都计算出来判断是否可以,但发现不仅计算量巨大且十分不好操作,这里我们可以使用Floyd(弗洛伊德)
算法来解决。
首先先简要介绍一下Folyd算法
,我们可以通过王卓老师一个视频来简单理解一下最短路径3–Floyd算法。
- 我们首先理解一下题目,题目要我们求的是从
k点出发,所有点都被访问到的最短时间
,那么我们发现这个问题可以转换一下,即可以变换为从k点出发,到其他点x的最短路径的最大值
问题。
明白上述题目转换后,我们就可以使用求解最短路径的Floyd算法进行求解。
- 我们首先通过一个
邻接矩阵matrix
来存储各个点之间的关系,matrix[u][v] = w
表示从u点到v点的最短距离w
。我们先将该邻接矩阵初始化,即按照对角线上元素值为0,其他元素值为无穷大
进行初始化。接着使用邻接矩阵保存times数组的数据,这样我们的第一步就完成了。 - 接着我们将得到的邻接矩阵
过一遍Folyd算法
即可得到我们想要的矩阵,此时矩阵里面存储的数值都已经是最短路径
,因此通过Floyd算法
也是可以求得任意两点之间的最短距离
。而此时我们想要的是从k点到其他点x的最短路径的最大值
,因此我们遍历点x,找到最大值的matrix[k][x]
即可。
本来应该是求从k点出发,刚好激活所有点出来的时间,但是这里由于我们将时间变化为了路径问题,此时我们是不知道谁是最后一个出来的点,而我们存储的又是各个点之间距离的最小值,因此要想知道哪个点是最后出来的点,只要看他的路径值是否最大即可,因为最后一个出来的点时间最大对应到路径上也是最大的。
- 在遍历的同时,还要判断一下邻接矩阵中是否存在从k点出发到不了的点,即是否存在
matrix[k][x]
为无穷值,如果存在则代表至少有一点我们无法到达,则此时不满足题意,返回-1即可。
这里需要注意我们不能在以后的算法题中尽量使用0x3f3f3f3f
作为我们的无穷大,而不是使用Integer.MAX_VALUE
,因为:
在算法竞赛中,我们常常需要用到设置一个常量用来代表“无穷大”。
比如对于int类型的数,有的人会采用INT_MAX,即0x7fffffff作为无穷大。但是以INT_MAX为无穷大常常面临一个问题,即加一个其他的数会溢出。
而这种情况在动态规划,或者其他一些递推的算法中常常出现,很有可能导致算法出问题。
所以在算法竞赛中,我们常采用0x3f3f3f3f来作为无穷大。0x3f3f3f3f主要有如下好处:
0x3f3f3f3f的十进制为1061109567,和INT_MAX一个数量级,即109数量级,而一般场合下的数据都是小于109的。
0x3f3f3f3f * 2 = 2122219134,无穷大相加依然不会溢出。
可以使用memset(array, 0x3f, sizeof(array))来为数组设初值为0x3f3f3f3f,因为这个数的每个字节都是0x3f。
代码:
class Solution {
int N = 200;
int[][] matrix = new int[N][N];
int maxValue = 0x3f3f3f3f;
public int networkDelayTime(int[][] times, int n, int k) {
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
if(i==j){
matrix[i][j] = 0;
}
else{
matrix[i][j] = maxValue;
}
}
}
for(int i=0;i<times.length;i++){
int u = times[i][0];
int v = times[i][1];
int w = times[i][2];
matrix[u][v] = w;
}
floyd(n);
int res = 0;
for(int i=1;i<=n;i++){
if(matrix[k][i]==maxValue){
return -1;
}
res = Math.max(res,matrix[k][i]);
}
return res;
}
public void floyd(int n){
for(int m=1;m<=n;m++){
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
matrix[i][j] = Math.min(matrix[i][j],matrix[i][m]+matrix[m][j]);
}
}
}
}
}
方法二:Dijkstra算法
Dijkstra算法
是用来求单源最短路的算法,根据题意,我们将k点作为源点,使用 Dijkstra 算法
我们可以得到从源点 k 到其他点 x 的最短距离,再从所有最短路中取 max即可。
代码:
class Solution {
int N = 200;
int[][] w = new int[N][N];
int[] dist = new int[N];
boolean[] vis = new boolean[N];
int INF = 0x3f3f3f3f;
public int networkDelayTime(int[][] times, int n, int k) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if(i==j){
w[i][j] = 0;
}
else{
w[i][j] = INF;
}
}
}
for (int[] t : times) {
int u = t[0], v = t[1], c = t[2];
w[u][v] = c;
}
dijkstra(n,k);
int ans = 0;
for (int i = 1; i <= n; i++) {
if(dist[i]==INF){
return -1;
}
ans = Math.max(ans, dist[i]);
}
return ans;
}
void dijkstra(int n , int k) {
Arrays.fill(vis, false);
Arrays.fill(dist, INF);
dist[k] = 0;
for (int p = 1; p <= n; p++) {
int t = -1;
for (int i = 1; i <= n; i++) {
if (!vis[i] && (t == -1 || dist[i] < dist[t])) t = i;
}
vis[t] = true;
for (int i = 1; i <= n; i++) {
dist[i] = Math.min(dist[i], dist[t] + w[t][i]);
}
}
}
}