bzoj 1758: [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

20%的数据,N<=5000
30%的数据,N<=100000,原有方案恰好为一条路径

100%的数据,N<=100000,1<=L<=U<=N-1,Vi<=1000000

因为ans的计算式里面有除法不太好处理。可是这是个求平均数，所以我们可以把每条边边权减去lim，然后看是否有一条长度为[l,u]的路径的权值为正就可以了。求路径这一块我们可以用点分治。s[k]记录深度为k的路径的最大长度，每棵子树dfs结束以后我们用单调队列维护下最大值看是否大于0就可以。

//一开始重心算错了一直T。后来单调队列各种爆炸

#include<cstdio>
#include<string>
#include<cstring>
#include<algorithm>
using namespace std;
struct line
{
     int s,t;
     double x;
     int next;
}a[200001];
int head[100001];
int edge;
inline void add(int s,int t,int x)
{
     a[edge].next=head[s];
     head[s]=edge;
     a[edge].s=s;
     a[edge].t=t;
     a[edge].x=x;
}
int n,l,u;
int minx,mini;
int dep;
int son[100001];
bool v[100001];
inline void find(int d,int fa,int s)
{
     son[d]=0;
     int i;
     int tmp=0;
     for(i=head[d];i!=0;i=a[i].next)
     {
          int t=a[i].t;
          if(!v[t]&&t!=fa)
          {
               find(t,d,s);
               son[d]+=(son[t]+1);
               tmp=max(tmp,son[t]+1);
          }
     }
     int mx=max(tmp,s-tmp-1);
     if(mx<minx||mx==minx&&d<mini)
     {
          minx=mx;
          mini=d;
     }
}
inline void dfsx(int d,int fa,int k)
{
	 son[d]=0;
	 dep=max(dep,k);
	 int i;
     for(i=head[d];i!=0;i=a[i].next)
     {
          int t=a[i].t;
          if(!v[t]&&t!=fa)
          {
               dfsx(t,d,k+1);
               son[d]+=(son[t]+1);
          }
     }
}
double sx[100001],st[100001];
inline void dfs(int d,int fa,int k,double dis,double lim)
{
     sx[k]=max(sx[k],dis);
     int i;
     for(i=head[d];i!=0;i=a[i].next)
     {
          int t=a[i].t;
          if(!v[t]&&t!=fa)
          {
               dfs(t,d,k+1,dis+(a[i].x-lim),lim);
          }
     }
}
int q[100001];
inline bool solve(int d,double lim)
{
     v[d]=true;
     int i,j;
     for(i=0;i<=dep;i++)
          st[i]=-2100000000;
     bool flag=false;
     for(i=head[d];i!=0;i=a[i].next)
     {
          int t=a[i].t;
          if(!v[t])
          {
          	   for(j=0;j<=dep;j++)
          	        sx[j]=-2100000000;
               dfs(t,d,1,a[i].x-lim,lim);
               int ll=0,rr=0;
               ll++;
               q[1]=0;
               int dx=dep;
               int sta=max(1,l-dep);
               while(dx+sta>=l)
               {
                    while(ll<=rr&&q[ll]+1>u)
                         ll++;
                    while(ll<=rr&&st[dx]>=st[q[rr]]&&dx+sta>=l)
                         rr--;
                    rr++;
                    q[rr]=dx;
                    dx--;
               }
               double maxt=0;
               for(j=sta;j<=dep;j++)
               {
               	    if(sx[j]==-2100000000)
               	         break;
                    while(ll<=rr&&q[ll]+j>u)
                         ll++;
                    //if(ll>rr)
                       //  break;
                    if(q[ll]+j>=l&&ll<=rr)
                         maxt=max(maxt,st[q[ll]]+sx[j]);
                    if(dx>0)
                    {
                         while(ll<=rr&&st[dx]+sx[j+1]>st[q[rr]]+sx[j+1]&&dx+j+1>=l)
                              rr--;
                         rr++;
                         q[rr]=dx;
                         dx--;
                    }
               }
               if(maxt>0)
               {
                    flag=true;
                    break;
               }
               for(j=1;j<=dep;j++)
                    st[j]=max(st[j],sx[j]);
          }
     }
     for(i=l;i<=min(u,dep);i++)
     {
          if(st[i]>0)
          {
               flag=true;
               break;
          }
     }
     if(flag)
          return true;
     for(i=head[d];i!=0;i=a[i].next)
     {
          int t=a[i].t;
          if(!v[t])
          {
               minx=2100000000;
               mini=0;
               dep=0; 
               find(t,d,son[t]);
               int root=mini;
               dfsx(root,0,0);
               if(son[root]>=l)
                    if(solve(root,lim))
                         return true;
          }
     }
     return false;
}
inline bool check(double lim)
{
     memset(v,false,sizeof(v));
     minx=2100000000;
     mini=0;
     dep=0;
     find(1,0,n);
     int root=mini;
     dfsx(root,0,0);
     if(solve(root,lim))
          return true;
     return false;
}
int main()
{
//     freopen("rebuild.in","r",stdin);
 //    freopen("rebuild.out","w",stdout);
     scanf("%d",&n);
     scanf("%d%d",&l,&u);
     int i;
     int s,t,x;
     int lim=0;
     for(i=1;i<=n-1;i++)
     {
          scanf("%d%d%d",&s,&t,&x);
          edge++;
          add(s,t,x);
          edge++;
          add(t,s,x);
          lim=max(lim,x);
     }
     double ll=0,rr=lim,mid;
     while(ll<=rr)
     {
          mid=(ll+rr)/(double)2;
          if(check(mid))
               ll=mid+0.0001;
          else
               rr=mid-0.0001;
     }
     printf("%.3lf\n",rr);
     return 0;
}