Codeforces 1453E E. Dog Snacks（二分+树形dp+贪心）

题目链接：E. Dog Snacks

题意：给定一颗树，每个点上有一个蛋糕，每次经过一个点会吃掉该点上蛋糕，从点1出发，每次可以到达距离当前点不超过k，且有蛋糕的点并吃掉点上蛋糕，求最小的k使得主角能吃掉所有蛋糕并回到1号点，

题解：我们可以发现答案的k必定是从1开始，以某个叶节点结尾的链的长度，那么显然这是个树形dp的题，我们可以维护以每个点为根的子树从根出发所需的最小k，转移时，贪心的把k最小的儿子作为转移点，但是我们发现，如果儿子们中存在某个儿子的贡献特别大，那么更新答案的可能就是某个儿子的贡献而不是树形dp的结果，因此我们需要二分答案，当儿子们贡献不超过枚举的答案时贪心的将最小的点作为最后遍历的，需要注意的是我们发现对于有多个儿子的根，除了最后经过的儿子以外，其他点都因为要去往别的儿子而导致要多加一点贡献，所以转移的时候需要注意是否有儿子的贡献恰好为k，如果有，应当优先把这个儿子作为最后遍历，防止答案超出枚举的上限（具体看代码及注释）

#include<iostream>
#include<stack>
#include<list>
#include<set>
#include<vector>
#include<algorithm>
#include<math.h>
#include<numeric>
#include<map>
#include<cstring>
#include<queue>
#include<iomanip>
#include<cmath>
#include<queue>
#include <bitset>
#include<unordered_map>
	#ifndef local
	#define endl '\n'
#endif 
#define mkp make_pair
using namespace std;
using std::bitset;
typedef long long ll;
typedef long double ld;
const int inf=0x3f3f3f3f;
const ll MAXN=2e6+10;
const ll N=2e5+100;
const ll mod=1e9+7;
const ll hash_p1=1610612741;
const ll hash_p2=805306457;
const ll hash_p3=402653189;
//-----------------------------------------------------------------------------------------------------------------*/
// ll head[MAXN],net[MAXN],to[MAXN],edge[MAXN]/*流量*/,cost[MAXN]//费用;
/* 
void add(ll u,ll v,ll w,ll s){
	to[++cnt]=v;net[cnt]=head[u];edge[cnt]=w;cost[cnt]=s;head[u]=cnt;
	to[++cnt]=u;net[cnt]=head[v];edge[cnt]=0;cost[cnt]=-s;head[v]=cnt;
}
struct elemt{
	int p,v;
};
-----------------------------------
求[1,MAXN]组合式和逆元 
ll mi(ll a,ll b){
	ll res=1;
	while(b){
		if(b%2){
			res=res*a%mod;
		}	
		a=a*a%mod;
		b/=2;
	}
	return res;
}
ll fac[MAXN+10],inv[MAXN+10]
ll C(int m,int n){//组合式C(m,n); 
	if(!n){
		return 1;
	}
	return fac[m]*(inv[n]*inv[m-n]%mod)%mod;
}
fac[0]=1;inv[0]=1;
for(ll i=1;i<=MAXN;i++){
	fac[i]=(fac[i-1]*i)%mod;
	inv[i]=mi(fac[i],mod-2);
}
---------------------------------
 unordered_map<int,int>mp;
//优先队列默认小顶堆 ， greater<int> --小顶堆  less<int> --大顶堆  
priority_queue<elemt,vector<elemt>,comp>q;
struct comp{
	public:
		bool operator()(elemt v1,elemt v2){
			return v1.v<v2.v;
		}
};
	set<int>::iterator it=st.begin();
*/
//emplace_back()  等于push_back(),但效率更高,传输pair时emplace_back(i,j)==push_back({i,j}) 
// vector<vector<int>>edge; 二维虚拟储存坐标 
//-----------------------------------------------------------------------------------------------------------------*/
  //map<int,bool>mp[N]; 
  //emplace_back() 
vector<int>edge[N];
int k[N];//以i为根的子树所需最小的k
void add(int u,int v){//建边
	edge[u].emplace_back(v);
	edge[v].emplace_back(u);
}
void init(int n){//初始化
	for(int i=1;i<=n;i++){
		edge[i].clear();
		k[i]=0;
	}
}
bool dfs(int x,int pre,int mid){
	k[x]=0;
	if(edge[x].size()==1&&x!=1){//叶子节点直接返回
		return 1;
	}
	int maxn=-1,minn=1e9;//维护儿子们中贡献最大和最小的
	int f=0;//记录贡献最大的儿子有几个
	for(int i=0;i<edge[x].size();i++){
		int tmp=edge[x][i];
		if(tmp==pre){
			continue;
		}
		if(dfs(tmp,x,mid)){//
			if(k[tmp]+1>maxn){
				maxn=k[tmp]+1;
				f=0;
			}
			else if(k[tmp]+1==maxn){
				f=1;
			}
			minn=min(minn,k[tmp]+1);
		}	
		else{
			return 0;
		}
	}
    if(edge[x].size()==2&&x!=1||edge[x].size()==1&&x==1){//路径只有一条
		k[x]=maxn;
	}
	else{
		if(maxn>mid||maxn==mid&&f){//最长路径超出上限或有多条路径为非最后路径时大于等于上限的都不可行
			return 0;
		}
		else if(maxn+1<=mid){//最长的路径不作为最后一次遍历时不超过限制，那么就贪心的把最短的最为最后遍历的那条
			k[x]=minn;
		}
		else{//否则只能尽量把最长的留作最后遍历的，以避免最长的超出限,那么此时的
			k[x]=maxn;
		}
	}
	return k[x]<=mid;
}
int main(){
/*cout<<setiosflags(ios::fixed)<<setprecision(8)<<ans<<endl;//输出ans（float）格式控制为8位小数（不含整数部分）*/
/*cout<<setprecision(8)<<ans<<endl;//输出ans（float）格式控制为8位小数（含整数部分）*/
	ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);//同步流
	int t;
	cin>>t;
	while(t--){
		int n;
		cin>>n;
		init(n);
		for(int i=1;i<n;i++){
			int u,v;
			cin>>u>>v;
			add(u,v);
		}
		int l=1,r=n,ans=r;
		while(l<=r){//二分答案
			int mid=(l+r)/2;
			if(dfs(1,0,mid)){
				ans=mid;
				r=mid-1;
			}
			else{
				l=mid+1;
			}
		}
		cout<<ans<<endl;
	}
	return 0;
}