本文已参与「新人创作礼」活动，一起开启掘金创作之路。

题目

2039.网络空闲的时刻

题目大意

给你一个有 n 个服务器的计算机网络，服务器编号为 0 到 n - 1 。同时给你一个二维整数数组 edges ，其中 edges[i] = [ui, vi] 表示服务器 ui 和 vi 之间有一条信息线路，在一秒内它们之间可以传输任意数目的信息。再给你一个长度为 n 且下标从 0 开始的整数数组 patience 。

题目保证所有服务器都是相通的，也就是说一个信息从任意服务器出发，都可以通过这些信息线路直接或间接地到达任何其他服务器。

编号为 0 的服务器是主服务器，其他服务器为数据服务器。每个数据服务器都要向主服务器发送信息，并等待回复。信息在服务器之间按最优线路传输，也就是说每个信息都会以 最少时间 到达主服务器。主服务器会处理所有新到达的信息并立即按照每条信息来时的路线 反方向 发送回复信息。

在 0 秒的开始，所有数据服务器都会发送各自需要处理的信息。从第 1 秒开始，每一秒最开始时，每个数据服务器都会检查它是否收到了主服务器的回复信息（包括新发出信息的回复信息）：

如果还没收到任何回复信息，那么该服务器会周期性重发信息。数据服务器 i 每 patience[i] 秒都会重发一条信息，也就是说，数据服务器 i 在上一次发送信息给主服务器后的 patience[i] 秒后会重发一条信息给主服务器。
否则，该数据服务器 不会重发 信息。

当没有任何信息在线路上传输或者到达某服务器时，该计算机网络变为空闲状态。

请返回计算机网络变为空闲状态的 最早秒数 。

样例

示例 1：

example 1

输入：edges = [[0,1],[1,2]], patience = [0,2,1]
输出：8
解释：
0 秒最开始时，
- 数据服务器 1 给主服务器发出信息（用 1A 表示）。
- 数据服务器 2 给主服务器发出信息（用 2A 表示）。

1 秒时，
- 信息 1A 到达主服务器，主服务器立刻处理信息 1A 并发出 1A 的回复信息。
- 数据服务器 1 还没收到任何回复。距离上次发出信息过去了 1 秒（1 < patience[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 秒开始，不再有任何信息在服务器之间传输，也不再有信息到达服务器。
所以第 8 秒是网络变空闲的最早时刻。

示例 2：

在这里插入图片描述

输入：edges = [[0,1],[0,2],[1,2]], patience = [0,10,10]
输出：3
解释：数据服务器 1 和 2 第 2 秒初收到回复信息。
从第 3 秒开始，网络变空闲。

数据规模

思路

先考虑对图建边，使用vector数组存储图中的边，考虑所有点i到节点 $0$ 的距离dist[i]。这里直接考虑bfs即可。初始所有节点的dist[i]=0x3f3f3f3f，并且dist[0]=0，然后进行bfs操作。

接下来就是对于每一个节点判断它发出的消息会在图中存在的最终时间（可能发出了多个消息）：

假如 $patience[i]\ge2\times dist[i]$ ，那么数据服务器不会发生重发动作，该节点活动停止时间点为 $dist[i]\times 2$
否则，数据服务器将会发生重发动作，且最后一个数据包的发送时间为 $(2\times dist[i]-1)\div patience[i]\times patience[i]$ ，只有当最后一个数据包收到回复，该节点的所有活动才算停止，最终停止的时间是 $(2\times dist[i]-1)\div patience[i]\times patience[i]+2\times dist[i]$ 。

所有节点的活动停止时间点的最大值 $+1$ 即是答案。

代码

// short int long float double bool char string void
// array vector stack queue auto const operator
// class public private static friend extern 
// sizeof new delete return cout cin memset malloc
// relloc size length memset malloc relloc size length
// for while if else switch case continue break system
// endl reverse sort swap substr begin end iterator
// namespace include define NULL nullptr exit equals 
// index col row arr err left right ans res vec que sta
// state flag ch str max min default charray std
// maxn minn INT_MAX INT_MIN push_back insert
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int>PII;
typedef pair<int, string>PIS;
const int maxn=1e5+50;//注意修改大小
long long read(){long long x=0,f=1;char c=getchar();while(!isdigit(c)){if(c=='-') f=-1;c=getchar();}while(isdigit(c)){x=x*10+c-'0';c=getchar();}return x*f;}
ll qpow(ll x,ll q,ll Mod){ll ans=1;while(q){if(q&1)ans=ans*x%Mod;q>>=1;x=(x*x)%Mod;}return ans%Mod;}

class Solution {
public:
    int dist[maxn];
    vector<int>a[maxn];
    void bfs(){
        queue<int>q;
        q.push(0);
        memset(dist,0x3f3f3f3f,sizeof(dist));
        dist[0]=0;
        while(!q.empty()){
            int x=q.front();q.pop();
            for(auto it:a[x]){
                if(dist[it]==0x3f3f3f3f){
                    dist[it]=dist[x]+1;
                    q.push(it);
                }
            }
        }
    }
    int networkBecomesIdle(vector<vector<int>>& edges, vector<int>& patience) {
        for(auto it:edges){
            int x=it[0],y=it[1];
            a[x].push_back(y);
            a[y].push_back(x);
        }
        bfs();
        int maxx=0;
        for(int i=1;i<patience.size();i++){
            if(patience[i]>=2*dist[i]){
                maxx=max(maxx,2*dist[i]);
            }
            else{
                maxx=max(maxx,(dist[i]*2-1)/patience[i]*patience[i]+2*dist[i]);
            }
        }
        return maxx+1;
    }
};