【bzoj1758】[Wc2010]重建计划

Description

Input

第一行包含一个正整数N，表示X国的城市个数. 第二行包含两个正整数L和U，表示政策要求的第一期重建方案中修建道路数的上下限 接下来的N-1行描述重建小组的原有方案，每行三个正整数Ai,Bi,Vi分别表示道路(Ai,Bi),其价值为Vi 其中城市由1..N进行标号

Output

输出最大平均估值，保留三位小数

Sample Input

4
2 3
1 2 1
1 3 2
1 4 3

Sample Output

2.500

HINT

N<=100000,1<=L<=U<=N-1,Vi<=1000000 新加数据一组 By leoly,但未重测..2016.9.27

题解：

　　好一个扫把树……长见识长见识。

　　显然二分答案+树的点分治。每次遍历一棵子树来得到$dis$数组，表示同一路径数的最大权值，然后再存一个之前遍历子树的桶，含义与$dis$一样，但是要注意从小到大处理每棵子树。扫把树……卡死人。

　　顺便一提，bzoj不会爆栈。

　　（空行比较多，所以显得很长……）

 #define Troy 09/30/2017

 #define inf 0x7fffffff

 #include <bits/stdc++.h>

 using namespace std;

 typedef long long ll;

 const int N=;
 const double eps=1e-;

 inline int read(){
     int s=,k=;char ch=getchar();
     while(ch<''|ch>'')  ch=='-'?k=-:,ch=getchar();
     while(ch>&ch<='')  s=s*+(ch^),ch=getchar();
     return s*k;
 }

 struct edges{
     int v;ll w;edges *last;
 }edge[N<<],*head[N];int cnt;

 inline void push(int u,int v,ll w){
     edge[++cnt]=(edges){v,w,head[u]};head[u]=edge+cnt;
 }

 int n,up,low,tot,top,root,size[N],heavy[N],T[N],Tdis[N],part,from;
 ll t[N],dis[N];
 bool vis[N];
 double ans,maxr;

 inline void dfs(int x,int fa,int deep){
     size[x]=;
     heavy[x]=;
     for(edges *i=head[x];i;i=i->last)if(i->v!=fa&&(!vis[i->v])){
         dfs(i->v,x,deep+);
         size[x]+=size[i->v];
         heavy[x]=max(size[i->v],heavy[x]);
     }
     heavy[x]=max(heavy[x],tot-size[x]);
     if(heavy[x]<top)
         top=heavy[x],root=x;
 }

 inline void calc(int x,int fa,ll d,int lens){
     if(lens>up)  return ;
     if(Tdis[lens]!=part){
         Tdis[lens]=part;
         dis[lens]=d;
     }else
         dis[lens]=max(dis[lens],d);
     for(edges *i=head[x];i;i=i->last)    if(i->v!=fa&&(!vis[i->v])){
         calc(i->v,x,d+i->w,lens+);
     }
 }

 inline void get_new(int x,int fa,ll d,int lens){
     if(lens>up)  return;
     if(T[lens]!=T[])
         T[lens]=T[],t[lens]=d;
     else
         t[lens]=max(t[lens],d);
     from=max(from,lens);
     for(edges *i=head[x];i;i=i->last)    if(i->v!=fa&&(!vis[i->v])){
         get_new(i->v,x,d+i->w,lens+);
     }
 }

 int q[N];
 double nq[N];

 inline bool Judge(double x){
     int l=,r=;
     int pos=min(up-,from);
     bool flag=;
     while(pos>=low){
         if(T[pos]!=T[]){
             pos--;continue;
         }
         while(r>l&&nq[r-]<t[pos]-x*pos)
             r--;
         nq[r]=t[pos]-x*pos;
         q[r++]=pos;
         pos--;
     }
     for(int i=low-pos;i<=up;i++){
         if(Tdis[i]!=part)   break;
         if(pos>=&&i+pos>=low&&T[pos]==T[]){
             while(r>l&&nq[r-]<t[pos]-x*pos)
                 r--;
             nq[r]=t[pos]-x*pos;
             q[r++]=pos;
         }
         while(l<r&&q[l]+i>up)
             l++;
         pos--;
         if(l<r&&nq[l]+dis[i]-i*x>=)
             return true;
     }
     return false;
 }

 struct node{
     int v,w;
     friend bool operator <(node x,node y){
         return size[x.v]<size[y.v];
     }
 }sons[N];

 inline void solve(int u){
     tot=size[u];
     top=inf;
     dfs(u,u,);
     vis[root]=true;
     T[]++;
     from=;
     int cc=;
     for(edges *i=head[root];i;i=i->last)if(!vis[i->v]){
         cc++;
         sons[cc].v=i->v;
         sons[cc].w=i->w;
     }
     sort(sons+,sons++cc);
     for(int i=;i<=cc;i++){
         if(i>){
                 part++;
                 calc(sons[i].v,,sons[i].w,);
                 double l=ans,r=maxr,mid;
                 while(l<r-eps){
                     mid=(l+r)/;
                     if(Judge(mid))  l=mid;
                     else    r=mid;
                 }
                 ans=l;
             }
             if(i<cc)
                 get_new(sons[i].v,,sons[i].w,);
     }
     for(edges *i=head[root];i;i=i->last) if(!vis[i->v])
         solve(i->v);
 }

 int main(){
     n=read();
     low=read(),up=read();
     for(int i=,u,v,w;i<n;i++){
         u=read(),v=read(),w=read();
         push(u,v,w),push(v,u,w);
         maxr=max(maxr,w+0.0);
     }
     size[]=n;
     solve();
     printf("%.3lf\n",ans);
 }