【NOIP2018】赛道修建【二分】【树形dp】【multiset】【贪心】

传送门

题意：给一棵带边权的树，求$M$条没有公共边的路径的最小长度的最大值。

$N\le 50000$

抛开NOIP不谈，其实这题本身出的很好

显然二分

问题转化成了“最多可以找多少条长度不小于$k$的路径”

递归处理

对于每个结点$i$，先统计它的子树剩下的链加上当前边权。

现在我们得到了若干个数，表示以$i$为顶的还没用过的链的长度

我们希望用这些数凑出$k$

大于等于$k$的可以直接统计答案

有如下贪心策略：从小到大二分最小的可以匹配的，最后把不能匹配的最长的作为剩下的链传回去

为什么？

首先，很显然尽量匹配小的

如果我们留了一条很长的链不匹配而要传上去，也最多产生$1$的贡献。而现在直接匹配也会有$1$的贡献，不配白不配。

为什么从小到大？

如果我们从大到小，或者用一些神奇的顺序，那就是出现大配小的情况。从小到大我们就算不匹配尽量小也能重现之前的状态，尽量小就肯定更优了。

用multiset维护即可。

细节有点多。注意大于等于$k$的必须在开始弹掉，否则可能浪费一个小的。

菊花图可能卡常，可以跑个直径作为二分上限。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cctype>
#include <set>
#define MAXN 50005
#define MAXM 100005
using namespace std;
struct edge{int u,v,w;}e[MAXM];
int head[MAXN],nxt[MAXM],cnt;
void addnode(int u,int v,int w)
{
	e[++cnt]=(edge){u,v,w};
	nxt[cnt]=head[u];
	head[u]=cnt;
}
int dp[MAXN];
int count(int u,int f,int k)
{
	multiset<int> s;
	int ans=0;
	for (int i=head[u];i;i=nxt[i])
		if (e[i].v!=f)
		{
			ans+=count(e[i].v,u,k);
			if (dp[e[i].v]+e[i].w>=k) ++ans;
			else s.insert(dp[e[i].v]+e[i].w);
		}
	while (!s.empty())
	{
		int mn=*s.begin();
		multiset<int>::iterator p=s.lower_bound(k-mn);
		if (p==s.begin()) ++p;
		if (p==s.end())
		{
			dp[u]=max(dp[u],mn);
			s.erase(s.begin());
			continue;
		}
		++ans;
		s.erase(p);
		s.erase(s.begin());
	}
	return ans;
}
int dis[MAXN];
void dfs(int u,int f)
{
	for (int i=head[u];i;i=nxt[i])
		if (e[i].v!=f)
		{
			dis[e[i].v]=dis[u]+e[i].w;
			dfs(e[i].v,u);
		}
}
int main()
{
	int n,m;
	scanf("%d%d",&n,&m);
	for (int i=1;i<n;i++)
	{
		int u,v,w;
		scanf("%d%d%d",&u,&v,&w);
		addnode(u,v,w);addnode(v,u,w);
	}
	dfs(1,0);
	int mx=0;
	for (int i=1;i<=n;i++) if (dis[i]>dis[mx]) mx=i;
	dis[mx]=0;
	dfs(mx,0);
	int l=0,r=0,mid;
	for (int i=1;i<=n;i++) r=max(r,dis[i]);
	while (l<r)
	{
		mid=(l+r+1)>>1;
		memset(dp,0,sizeof(dp));
		if (count(1,0,mid)>=m) l=mid;
		else r=mid-1;
	}
	printf("%d\n",l);
	return 0;
}