Shik and Travel

题目传送门

第一次过黑题，才打了48行
$发现每一条边只能且必须遍历两遍，手动模拟或直接证明可以知道一个结论$
$如果遍历到一颗子树，那么就一定要把这棵子树遍历完才能遍历下一棵$
$这样就很容易想到利用树形DP的方法，同时又具有单调性，可以用二分,记二分的数值为value$
$发现这个题目的树是一个二叉树，而且不是叶子就一定有2个儿子的那种$
$可以用一个f[x]表示从x点出发遍历到a叶子的长度，结尾再遍历到b叶子的长度的所有满足\le value的值(用vector储存)$
$只需要用儿子节点转移即可$
$考虑如何转移$
$记一颗树的一个儿子为ls,另外一个为rs,两个点的边分别为lv,rv.很显然,f[x]的(a,b)一个在ls子树内，一个在rs子树内$
$f[x]=\{\begin{array}{l}(f[x.ls].lft+lv,f[x.rs].lft)\\ (f[x.ls].lft+lv,f[x.rs].rgh)\\ (f[x.ls].rgh+lv,f[x.rs].lft)\\ (f[x.ls].rgh+lv,f[x.rs].rgh)\\ 这里的f是个结构体，代表着所有的点对,lft表示点对的左值，rgh表示点对的右值\end{array}$
$画个图就能明白：$

$$\begin{gathered} 但是很容易就想到这样很显然是不可能全部转移，因为方案数实在太多了，但是一定会有很多的冗杂的信息 \\ 考虑怎么优化，可以发现对于两个决策(v{1}_a,v{1}_b)）,(v{2}_a,v{2}_b)，如果v{1}_a<v{2}_a,v{1}_b<v{2}_b,那么后面的那个决策一定是没有必要的 \end{gathered}$$
$那么这样子的优化后，排序一定是具有单调性的，假设按第一关键字排序,就是第一个数持续递增，第二个数持续递减，那么就可以发现对于两个儿子合并的时候就可以用双指针优化$
$时间复杂度O(nlo{g}^{2}n)$不会证

#include<bits/stdc++.h>
using namespace std;
const int N=2e5+10;
#define ll long long
#define P pair<ll,ll>
#define ls lb[x].son
#define rs rb[x].son
#define lv lb[x].v
#define rv rb[x].v
#define fi first
#define se second
struct cow{int son,v;}lb[N],rb[N];
int n,a[N];vector<P>f[N];
void dfs(int x,ll v){
	f[x].clear();
	if(!ls){f[x].push_back((P){0,0});return ;}
	vector<P>now;dfs(ls,v);dfs(rs,v);
	for(int o=0;o<2;o++){
		ll tmp=v-lv-rv;
		for(int i=0,j=0;i<f[ls].size();i++){
			while(j+1<f[rs].size()&&f[rs][j+1].fi+f[ls][i].se<=tmp)j++;
			if(j>=f[rs].size()||f[rs][j].fi+f[ls][i].se>tmp)continue;
			now.push_back((P){f[ls][i].fi+lv,f[rs][j].se+rv});
		}swap(lv,rv);swap(ls,rs);
	}sort(now.begin(),now.end());
	for(int i=0;i<now.size();i++){
	  if(!f[x].empty()&&f[x].back().se<=now[i].se)
	  continue;f[x].push_back(now[i]);
	}
}
bool check(ll mid){
	dfs(1,mid);return f[1].size()>=1;
}
int main()
{
	scanf("%d",&n);ll l=0,r=0;
	for(int i=2;i<=n;i++){
		int fa,v;scanf("%d%d",&fa,&v);
		if(lb[fa].son)rb[fa]=(cow){i,v};
		  else lb[fa]=(cow){i,v};r+=v;
	}
	while(l<r){
		ll mid=l+r>>1;
		if(check(mid))r=mid;
		  else l=mid+1;
	}
	printf("%lld",l);return 0;
}