There is a network of `n` servers, labeled from `0` to `n - 1`. You are given a 2D integer array `edges`, where `edges[i] = [ui, vi]` indicates there is a message channel between servers `ui` and `vi`, and they can pass **any** number of messages to **each other** directly in **one** second. You are also given a **0-indexed** integer array `patience` of length `n`.

All servers are **connected**, i.e., a message can be passed from one server to any other server(s) directly or indirectly through the message channels.

The server labeled `0` is the **master** server. The rest are **data** servers. Each data server needs to send its message to the master server for processing and wait for a reply. Messages move between servers **optimally**, so every message takes the **least amount of time** to arrive at the master server. The master server will process all newly arrived messages **instantly** and send a reply to the originating server via the **reversed path** the message had gone through.

At the beginning of second `0`, each data server sends its message to be processed. Starting from second `1`, at the **beginning** of **every** second, each data server will check if it has received a reply to the message it sent (including any newly arrived replies) from the master server:

*   If it has not, it will **resend** the message periodically. The data server `i` will resend the message every `patience[i]` second(s), i.e., the data server `i` will resend the message if `patience[i]` second(s) have **elapsed** since the **last** time the message was sent from this server.
*   Otherwise, **no more resending** will occur from this server.

The network becomes **idle** when there are **no** messages passing between servers or arriving at servers.

Return _the **earliest second** starting from which the network becomes **idle**_.

**Example 1:**

**Input:** edges = \[\[0,1\],\[1,2\]\], patience = \[0,2,1\]
**Output:** 8
**Explanation:**
At (the beginning of) second 0,
- Data server 1 sends its message (denoted 1A) to the master server.
- Data server 2 sends its message (denoted 2A) to the master server.

At second 1,
- Message 1A arrives at the master server. Master server processes message 1A instantly and sends a reply 1A back.
- Server 1 has not received any reply. 1 second (1 < patience\[1\] = 2) elapsed since this server has sent the message, therefore it does not resend the message.
- Server 2 has not received any reply. 1 second (1 == patience\[2\] = 1) elapsed since this server has sent the message, therefore it resends the message (denoted 2B).

At second 2,
- The reply 1A arrives at server 1. No more resending will occur from server 1.
- Message 2A arrives at the master server. Master server processes message 2A instantly and sends a reply 2A back.
- Server 2 resends the message (denoted 2C).
...
At second 4,
- The reply 2A arrives at server 2. No more resending will occur from server 2.
...
At second 7, reply 2D arrives at server 2.

Starting from the beginning of the second 8, there are no messages passing between servers or arriving at servers.
This is the time when the network becomes idle.

**Example 2:**

**Input:** edges = \[\[0,1\],\[0,2\],\[1,2\]\], patience = \[0,10,10\]
**Output:** 3
**Explanation:** Data servers 1 and 2 receive a reply back at the beginning of second 2.
From the beginning of the second 3, the network becomes idle.

**Constraints:**

*   `n == patience.length`
*   `2 <= n <= 105`
*   `patience[0] == 0`
*   `1 <= patience[i] <= 105` for `1 <= i < n`
*   `1 <= edges.length <= min(105, n * (n - 1) / 2)`
*   `edges[i].length == 2`
*   `0 <= ui, vi < n`
*   `ui != vi`
*   There are no duplicate edges.
*   Each server can directly or indirectly reach another server.

0`에서 `n - 1`까지 레이블이 붙은 `n`개의 서버 네트워크가 있습니다. 2차원 정수 배열 `에지`가 주어지는데, 여기서 `에지[i] = [ui, vi]`는 서버 `ui`와 `vi` 사이에 메시지 채널이 있으며, 이들은 1초 안에 **모든** 수의 메시지를 **서로** 직접 전달할 수 있음을 나타냅니다. 또한 길이 'n'의 **0 인덱싱된** 정수 배열 '인내심'이 주어집니다.

모든 서버는 **연결**되어 있으며, 즉 메시지 채널을 통해 한 서버에서 다른 서버로 메시지를 직접 또는 간접적으로 전달할 수 있습니다.

0`으로 표시된 서버는 **마스터** 서버입니다. 나머지는 **데이터** 서버입니다. 각 데이터 서버는 처리를 위해 마스터 서버로 메시지를 전송하고 응답을 기다려야 합니다. 메시지는 서버 간에 **최적으로** 이동하므로 모든 메시지가 마스터 서버에 도착하는 데 **최소한의 시간**이 소요됩니다. 마스터 서버는 새로 도착한 모든 메시지를 **즉시** 처리하고 메시지가 거쳤던 **역방향 경로**를 통해 발신 서버로 답장을 보냅니다.

초 `0`이 시작될 때, 각 데이터 서버는 처리할 메시지를 보냅니다. 초 `1`부터 매 **초 **시작**할 때마다 각 데이터 서버는 마스터 서버로부터 자신이 보낸 메시지에 대한 회신(새로 도착한 회신 포함)을 받았는지 확인합니다:

* 수신하지 못한 경우 주기적으로 메시지를 **재전송**합니다. 데이터 서버 `i`는 매 `인내심[i]` 초마다 메시지를 다시 보냅니다. 즉, 이 서버에서 메시지를 마지막으로 보낸 후 `인내심[i]` 초가 경과한 경우 데이터 서버 `i`가 메시지를 다시 보냅니다.
* 그렇지 않으면 이 서버에서 **더 이상 재전송이 발생하지 않습니다**.

서버 간에 전달되거나 서버에 도착하는 메시지가 **없으면 네트워크는 **유휴 상태**가 됩니다.

네트워크가 **유휴 상태가 되는 **가장 빠른 시간**을 반환합니다.

**예제 1:**

**입력:** edges = \[\[0,1\],\[1,2\]\], patience = \[0,2,1\]
**출력:** 8
**설명:**
(시작되는) 초 0에,
- 데이터 서버 1은 메시지(1A로 표시됨)를 마스터 서버로 보냅니다.
- 데이터 서버 2는 메시지(2A로 표시됨)를 마스터 서버로 보냅니다.

초 1에
- 메시지 1A가 마스터 서버에 도착합니다. 마스터 서버는 메시지 1A를 즉시 처리하고 응답 1A를 다시 보냅니다.
- 서버 1은 응답을 받지 못했습니다. 이 서버가 메시지를 보낸 후 1초(1 < 인내심\[1\] = 2)가 경과되었으므로 메시지를 다시 보내지 않습니다.
- 서버 2가 응답을 받지 못했습니다. 이 서버가 메시지를 보낸 후 1초(1 == patience\[2\] = 1)가 경과되었으므로 메시지를 다시 보냅니다(2B로 표시됨).

두 번째 2,
- 응답 1A가 서버 1에 도착합니다. 서버 1에서 더 이상 재전송이 발생하지 않습니다.
- 메시지 2A가 마스터 서버에 도착합니다. 마스터 서버는 메시지 2A를 즉시 처리하고 회신 2A를 다시 보냅니다.
- 서버 2가 메시지를 다시 보냅니다(2C로 표시됨).
...
두 번째 4,
- 응답 2A가 서버 2에 도착합니다. 서버 2에서 더 이상 재전송이 발생하지 않습니다.
...
초 7에 응답 2D가 서버 2에 도착합니다.

두 번째 8의 시작부터 서버 간에 전달되거나 서버에 도착하는 메시지가 없습니다.
네트워크가 유휴 상태가 되는 시간입니다.

**예제 2:**

**입력:** edges = \[\[0,1\],\[0,2\],\[1,2\]\], patience = \[0,10,10\]
**출력:** 3
**설명:** 데이터 서버 1과 2는 두 번째 2가 시작될 때 응답을 다시 받습니다.
두 번째 3이 시작될 때부터 네트워크는 유휴 상태가 됩니다.

**제약 조건:**

* `n == patience.length`
* `2 <= n <= 105`
* `patience[0] == 0`
* `1 <= patience[i] <= 105` for `1 <= i < n`
* `1 <= edges.length <= min(105, n * (n - 1) / 2)`
* `edges[i].length == 2`
* `0 <= ui, vi < n`
* `ui != vi`
* 중복 에지는 없습니다.
* 각 서버는 다른 서버에 직접 또는 간접적으로 연결할 수 있습니다.
