CF1039D You Are Given a Tree 整体二分 树形dp

题目链接

题意：
给你一棵$n$个点的树，问你点数为$k$的互不相交的路径数最多有多少条。要求你对$[1,n]$的每一个$k$都输出答案。$n<=1e5$。

题解：
如果只有一个$k$要求答案的话，就有点类似今年NOIP的Day1T3，但是其实那个题要是是边不想交的话合并要二分，或者按照一定顺序。这个点不相交的话就直接维护最长链和次长链贪心合并就可了。

那么我们考虑对于每一个$k$应该怎么做。不难发现，我们会发现对于某一个$k$，有$ans[k]<=n/k$，那么其实对于所有的$[1,n]$的每个数的答案都只会有$\sqrt{n}$种答案。我们对于一个左端点，可以二分找到一个右端点。这样就可以做到复杂度$O(n\sqrt{n}logn)$了。

我这里写了一个整体二分的东西，复杂度看上去有点真，但是一想，好像不是$nlogn$的，要是你每个区间都$O(n)$树形dp一遍，反而成了一个$O(n^2)$的东西了。但是再一想，我要是在这个值一定之后就不再往下递归的话，复杂度应该就和上面那种做法一样了，也是$O(n\sqrt{n}logn)$了。

但是实测的话，似乎没有第一种做法跑得快。主要是想回顾一下整体二分。

代码：

#include <bits/stdc++.h>
using namespace std;

int n,hed[100010],cnt,ans[100010],dp[100010];
struct node
{
	int to,next;
}a[200010];
inline int read()
{
	int x=0;
	char s=getchar();
	while(s>'9'||s<'0')
	s=getchar();
	while(s>='0'&&s<='9')
	{
		x=x*10+s-'0';
		s=getchar();
	}
	return x;
}
inline void add(int from,int to)
{
	a[++cnt].to=to;
	a[cnt].next=hed[from];
	hed[from]=cnt;
}
inline void dfs(int x,int f,int s)
{
	dp[x]=0;
	int zui=0,ci=0;
	for(int i=hed[x];i;i=a[i].next)
	{
		int y=a[i].to;
		if(y==f)
		continue;
		dfs(y,x,s);
		if(dp[y]>zui)
		{
			ci=zui;
			zui=dp[y];
		}
		else if(dp[y]>ci)
		ci=dp[y]; 
	}
	if(zui+ci+1>=s)
	++cnt;
	else
	dp[x]=zui+1;
}
inline void solve(int l,int r,int le,int ri)
{
	if(l>r)
	return;
	if(le>ri)
	return;
	if(le==ri)
	{
		for(int i=l;i<=r;++i)
		ans[i]=le;
		return;
	}
	int mid=(l+r)>>1;
	cnt=0;
	dfs(1,0,mid);
	ans[mid]=cnt;
	solve(l,mid-1,cnt,ri);
	solve(mid+1,r,le,cnt);
}
int main()
{
	n=read();
	for(int i=1;i<=n-1;++i)
	{
		int x=read(),y=read();
		add(x,y);
		add(y,x);
	}
	solve(1,n,0,n);
	for(int i=1;i<=n;++i)
	printf("%d\n",ans[i]);
	return 0;
}