這題需要運用到廣度優先搜尋的知識

廣度優先搜尋之後可以得到每個節點到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的下一秒就是網路開始空閒的第一秒。

程式碼

 1
 
 class Solution {
 2     public int networkBecomesIdle(int[][] edges, int[] patience) {
 3         //廣度優先搜尋
 4         int n = patience.length;
 5         boolean[] visited = new boolean[n];
 6         List<Integer>[] map = new List[n];
 7         for(int i = 0; i < n; i++){
 8             map[i] = new
 
 ArrayList<>();
 9         }
10         int len = edges.length;
11         for(int i = 0; i < len; i++){
12             int ui = edges[i][0];
13             int vi = edges[i][1];
14             map[ui].add(vi);
15             map[vi].add(ui);
16         }
17         Deque<Integer> que = new ArrayDeque<Integer>();
18         que.offer(0);
19         visited[0] = true;
20         int retTime = 0;//當前節點的往返時間
21         int ans = 0;
22         while(!que.isEmpty()){
23             int size = que.size();
24             retTime += 2;
25             for(int i = 0; i < size; i++){
26                 int cur = que.poll();
27                 List<Integer> nextList = map[cur];
28                 for(Integer next : nextList){
29                     if(!visited[next]){
30                         visited[next] = true;
31                         que.offer(next);
32                         int left = retTime % patience[next];
33                         int timei = 0;
34                         if(left > 0){
35                             timei = (retTime / patience[next]) * patience[next] + retTime;
36                         }else if(left == 0){
37                             timei = ((retTime / patience[next]) - 1) * patience[next] + retTime;
38                         }
39                         ans = Math.max(ans,timei);
40                     }
41                 }
42             }
43         }
44         return ans + 1;
45 
46         /*
47         n = patience.length;
48         int[] retTime = new int[n];每個節點往返所需的最小時間
49         餘數 = (retTime[i]) % patience[i];
50         if(餘數 > 0){
51             timei = ((retTime[i]) / patience[i]) * patience[i] + (retTime[i]);
52         }else if(餘數 == 0){
53             timei = (((retTime[i]) / patience[i]) -1) * patience[i] + (retTime[i]);
54         }
55         ans = Math.max(timei,ans);
56         
57         return ans + 1;
58         
59         */
60     }
61 }