Codeforces Round #781(C. Tree Infection)

Codeforces Round #781

C. Tree Infection

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. The parent of a vertex vv (different from root) is the previous to vv vertex on the shortest path from the root to the vertex vv. Children of the vertex vv are all vertices for which vv is the parent.

You are given a rooted tree with nn vertices. The vertex 11 is the root. Initially, all vertices are healthy.

Each second you do two operations, the spreading operation and, after that, the injection operation:

1. Spreading: for each vertex vv, if at least one child of vv is infected, you can spread the disease by infecting at most one other child of vv of your choice.
2. Injection: you can choose any healthy vertex and infect it.

This process repeats each second until the whole tree is infected. You need to find the minimal number of seconds needed to infect the whole tree.

Input

The input consists of multiple test cases. The first line contains a single integer tt (1≤t≤1e4) — the number of test cases. Description of the test cases follows.

The first line of each test case contains a single integer nn (2≤n≤2e5) — the number of the vertices in the given tree.

The second line of each test case contains n−1n−1 integers p2,p3,…,pnp2,p3,…,pn (1≤pi≤n), where pipi is the ancestor of the ii-th vertex in the tree.

It is guaranteed that the given graph is a tree.

It is guaranteed that the sum of nn over all test cases doesn't exceed 2e5.

 

 

 

# include<iostream>
# include<algorithm>
# include<queue>
# define int long long
# define endl "\n"
using namespace std;
const int N = 1000050;
int f[N],vis[N];

void solve(){
    int n;
    cin>>n;
    for(int i = 1;i <= n;++i) f[i] = 0;
    for(int i = 2;i <= n;++i){
        int x;
        cin>>x;
        f[x]++;
    }
    int l = 1,r = n,res = n;
    while(l <= r){
        int mid = (l+r)>>1;
        for(int i = 0;i <= n;++i) vis[i] = 0;
        priority_queue<pair<int,int> > q;
        
        for(int i = 1;i <= n;++i) if(f[i]) q.push({f[i],i});
        q.push({1,0});
        for(int i = 1;i <= mid;++i){
            if(q.empty()) break;
            auto now = q.top();q.pop();
            if(!vis[now.second]) now.first -=mid - i+1,vis[now.second] = 1;
            else now.first--;
            if(now.first > 0) q.push(now);
        }
        if(q.empty()) res = mid,r = mid-1;
        else l = mid+1;
    }
    cout<<res<<endl;
}

int tt;
signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin>>tt;
    while(tt--){
        solve();
    }
    
    
    return 0;
}

　　二分实在是精彩

根据题意将相同父节的个数进排序，每次对个数最多的进行操作

如果尚未被感染则选择注射，如果已经被注射过，则选择传播给相同父节点的子节点

通过priority_queue来进行排序，每次取对头进行操作，通过vis进行对节点(相同父节点)的判断是否被感染过

 

而二分的是操作次数（二分答案），有两种可能，如果操作次数内使得队列为空说明在当前操作次数可以满足全部感染，继续查找更小的操作次数

否则就不能满足全部感染，查找更大的操作次数