2022/03/20每日一题 LeetCode_2039

这题需要运用到广度优先搜索的知识

广度优先搜索之后可以得到每个节点到0节点的所需的最小往返时间

int[] retTime = new int[n];//每个节点往返所需的最小时间

那么就可以进行分情况讨论，分为如下两种情况

余数 = (retTime[i]) % patience[i];

 

1.有余数（即余数大于零)

节点重发数据的次数=往返的时间/等待的时间

timei = ((retTime[i]) / patience[i]) * patience[i] + (retTime[i]);

 

2.刚刚好整除（即余数等于零）

节点重发数据的次数=（往返的时间/等待的时间）-1

为什么这里就要-1呢？

因为从题目的描述中可以看到，在每一秒的最开始会进行检测是否有收到回复信息，也就是说会先检测，再回复；

所以说，刚刚好整除时，会出现要发送信息时回复信息已经到达的时间节点，由于是先检测，此时这个信息没有发送出去。

timei = ((retTime / patience[next]) - 1) * patience[next] + retTime;

然后只需要取时间的最大值即可

ans = Math.max(ans,timei);

最后返回

ans+1

为什么要+1？

因为题目要求从那一秒开始网络有空闲，而ans是网络繁忙的最后一秒，因此ans的下一秒就是网络开始空闲的第一秒。

代码

class Solution {
    public int networkBecomesIdle(int[][] edges, int[] patience) {
        //广度优先搜索
        int n = patience.length;
        boolean[] visited = new boolean[n];
        List<Integer>[] map = new List[n];
        for(int i = 0; i < n; i++){
            map[i] = new ArrayList<>();
        }
        int len = edges.length;
        for(int i = 0; i < len; i++){
            int ui = edges[i][0];
            int vi = edges[i][1];
            map[ui].add(vi);
            map[vi].add(ui);
        }
        Deque<Integer> que = new ArrayDeque<Integer>();
        que.offer(0);
        visited[0] = true;
        int retTime = 0;//当前节点的往返时间
        int ans = 0;
        while(!que.isEmpty()){
            int size = que.size();
            retTime += 2;
            for(int i = 0; i < size; i++){
                int cur = que.poll();
                List<Integer> nextList = map[cur];
                for(Integer next : nextList){
                    if(!visited[next]){
                        visited[next] = true;
                        que.offer(next);
                        int left = retTime % patience[next];
                        int timei = 0;
                        if(left > 0){
                            timei = (retTime / patience[next]) * patience[next] + retTime;
                        }else if(left == 0){
                            timei = ((retTime / patience[next]) - 1) * patience[next] + retTime;
                        }
                        ans = Math.max(ans,timei);
                    }
                }
            }
        }
        return ans + 1;

        /*
        n = patience.length;
        int[] retTime = new int[n];每个节点往返所需的最小时间
        余数 = (retTime[i]) % patience[i];
        if(余数 > 0){
            timei = ((retTime[i]) / patience[i]) * patience[i] + (retTime[i]);
        }else if(余数 == 0){
            timei = (((retTime[i]) / patience[i]) -1) * patience[i] + (retTime[i]);
        }
        ans = Math.max(timei,ans);
        
        return ans + 1;
        
        */
    }
}