WC2010 重建计划
这道题……如bin哥所说，算法不难想，但是很难写，而且还有些卡常……
其实这题我做的很奇怪……就是大致的算法都是对的但是我和别人的实现方法一点都不一样……（我怎么总是这么奇怪的做题）
因为要求平均值，所以就可以想到01分数规划，二分答案，然后要求的是树上的一条路径，那就是点分治咯。想到这就已经是两个\(log\)了，如果要是三个\(log\)估计死活过不去。再考虑考虑怎么合并，合并的复杂度还必须是\(O(n)\)的。借鉴着上一道题的做法，很自然能想到用\(dis_x\)表示重心的每棵子树中长度为\(x\)的路径的长度，只需要保留最长的那一条就行了，这个直接dfs一遍就行（但是好像所有人都用bfs？）之后就是咋合并了。
用\(tmp_i\)表示前s-1棵子树之内长为i的路径最大值。发现每一条路径只能和长度在一段区间之内的路径合并更新答案，然后这个区间随着枚举的值左右端点都递增，那么使用单调队列维护一下就好。
结果写的时候感觉自己像没学过单调队列……写错两次。这里我的实现方法是，从小到大枚举当前子树的链长，先倒着把长度为\(l+1～u\)的链放在单调队列里，然后每次枚举的时候把长度为\(l-i\)的压入单调队列，之后就都一样了。最后要更新答案，并且把数组还原回\(-INF\)，方便之后递归使用。
别人都是对于每一个重心二分答案，然后我是……直接在外面二分答案，然后把最长链求完更新。所以一开始我还建了点分树。程序一开始交上去T了8个点……后来改小了二分的次数（其实35次就够用了），在合并过程中，我记录子树链长最大值\(maxdep\)，这样单调队列一开始只需要压入\(l+1～maxdep\)的值就可以了。这样其实可以过了，不过还是挺慢的……
最后加了个重要剪枝，子树\(size\)小于\(l\)的不建点分树，然后还优化了一下其他的小地方，比原来快了很多。发现自己和hzwer跑的差不多快，干脆不卡了，就这样吧。
看一下代码。
#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<queue>
#include<cstring>
#define rep(i,a,n) for(register int i = a;i <= n;i++)
#define per(i,n,a) for(register int i = n;i >= a;i--)
#define enter putchar('\n')
#define pr pair<int,int>
#define mp make_pair
#define fi first
#define sc second
using namespace std;
typedef long long ll;
const int M = 100005;
const int N = 10000005;
const double INF = 1e13;
int read()
{
int ans = 0,op = 1;
char ch = getchar();
while(ch < '0' || ch > '9')
{
if(ch == '-') op = -1;
ch = getchar();
}
while(ch >='0' && ch <= '9')
{
ans *= 10;
ans += ch - '0';
ch = getchar();
}
return ans * op;
}
struct edge
{
int next,to;
double d,v;
}e[M<<1],e1[M<<1];
int n,size[M],hson[M],G,sum,l,u,x,y,Head,tail,q[M],head[M],ecnt,fq[M],st;
int head1[M],ecnt1,dep[M],mdep,maxdep;
double z,ans,tmp[M],dis[M],L,R,mid;
bool vis[M];
inline void add(int x,int y,double z)
{
e[++ecnt].to = y;
e[ecnt].d = z;
e[ecnt].next = head[x];
head[x] = ecnt;
}
inline void add1(int x,int y)
{
e1[++ecnt1].to = y;
e1[ecnt1].next = head1[x];
head1[x] = ecnt1;
}
void getG(int x,int fa)
{
size[x] = 1,hson[x] = 0;
for(int i = head[x];i;i = e[i].next)
{
if(vis[e[i].to] || e[i].to == fa) continue;
getG(e[i].to,x);
size[x] += size[e[i].to],hson[x] = max(hson[x],size[e[i].to]);
}
hson[x] = max(hson[x],sum - size[x]);
if(hson[x] < hson[G]) G = x;
}
void build(int x)
{
vis[x] = 1;
for(int i = head[x];i;i = e[i].next)
{
if(vis[e[i].to] || size[e[i].to] < l) continue;
sum = size[e[i].to],G = 0;
getG(e[i].to,x),add1(x,G);
build(G);
}
vis[x] = 0;
}
void getdis(int x,int fa,double d,int depth)
{
dis[depth] = max(dis[depth],d),mdep = max(mdep,depth);
for(int i = head[x];i;i = e[i].next)
{
if(vis[e[i].to] || e[i].to == fa) continue;
getdis(e[i].to,x,d+e[i].v-mid,depth+1);
}
}
void solve(int x)
{
int cur = 0;
vis[x] = 1,maxdep = 0;
for(int i = head[x];i;i = e[i].next)
{
if(vis[e[i].to]) continue;
cur++,mdep = 0;
getdis(e[i].to,x,e[i].v-mid,1);
maxdep = max(maxdep,mdep);
if(cur != 1)
{
Head = 1,tail = 0;
per(j,min(maxdep,u),l+1)
{
while(Head <= tail && tmp[q[tail]] <= tmp[j]) tail--;
q[++tail] = j;
}
rep(j,0,mdep)
{
while(Head <= tail && tmp[q[tail]] <= tmp[l-j]) tail--;
q[++tail] = l-j;
while(Head <= tail && q[Head] + j > u) Head++;
ans = max(ans,dis[j] + tmp[q[Head]]);
}
}
rep(j,1,mdep) tmp[j] = max(tmp[j],dis[j]),dis[j] = -INF;
}
rep(i,1,maxdep) tmp[i] = dis[i] = -INF;
for(int i = head1[x];i;i = e1[i].next) solve(e1[i].to);
vis[x] = 0;
}
int main()
{
n = read(),l = read(),u = read();
rep(i,1,n-1) x = read(),y = read(),scanf("%lf",&z),add(x,y,z),add(y,x,z);
L = 0,R = 1e6;
G = 0,sum = n,hson[G] = n;
getG(1,0),st = G,build(G);
rep(i,1,n) dis[i] = tmp[i] = -INF;
rep(t,1,35)
{
double mid = (L+R) / 2.0;
ans = -INF,solve(st);
if(ans > 0) L = mid;
else R = mid;
}
printf("%.3lf\n",L);
return 0;
}
