[WC 2010]重建计划

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

题解

本机实测是可以 $A$ 的，但爆炸 $oj$ 的老爷机实在不可恭维，并且还多加了一组更为毒瘤的数据...

加了所有的常数优化都过不了，气愤的不想写题解，直接丢链接。

->题解在这里<-

 //It is made by Awson on 2018.1.5
 #include <set>
 #include <map>
 #include <cmath>
 #include <ctime>
 #include <queue>
 #include <stack>
 #include <cstdio>
 #include <string>
 #include <vector>
 #include <cstdlib>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #define LL long long
 #define RE register
 #define lowbit(x) ((x)&(-(x)))
 #define Max(a, b) ((a) > (b) ? (a) : (b))
 #define Min(a, b) ((a) < (b) ? (a) : (b))
 using namespace std;
 const int N = ;
 const int INF = ~0u>>;
 const double eps = 4e-;
 void read(int &x) {
     char ch; x = ;
     ch = getchar(); while (ch < '' || ch > '') ch = getchar();
     while (ch >= '' && ch <= '') x = (x<<)+(x<<)+ch-, ch = getchar();
 }

 int n, L, U, a, b, c;
 struct tt {
     int to, next;
     double cost, c;
 }edge[(N<<)+];
 int path[N+], top;
 int root[N+];
 void add(int u, int v, double c) {
     edge[++top].to = v;
     edge[top].cost = edge[top].c = c;
     edge[top].next = path[u];
     path[u] = top;
 }

 namespace PRE {
     int size[N+], mx[N+], minsize, rt, vis[N+], tot;
     void get_root(int o, int pa, int fa) {
     mx[o] = Max(mx[o], size[pa]-size[o]);
     if (mx[o] < minsize) minsize = mx[o], rt = o;
     for (RE int i = path[o]; i; i = edge[i].next)
         if (edge[i].to != fa && !vis[edge[i].to]) get_root(edge[i].to, pa, o);
     }
     void get_size(int o, int fa) {
     size[o] = , mx[o] = ;
     for (RE int i = path[o]; i; i = edge[i].next)
         if (edge[i].to != fa && !vis[edge[i].to]) {
         get_size(edge[i].to, o);
         size[o] += size[edge[i].to];
         if (size[edge[i].to] > mx[o]) mx[o] = size[edge[i].to];
         }
     }
     void work(int o) {
     minsize = INF;
     get_size(o, ), get_root(o, o, );
     root[++tot] = rt, vis[rt] = ;
     for (RE int i = path[rt]; i; i = edge[i].next)
         if (!vis[edge[i].to]) work(edge[i].to);
     }
     void main() {work(); }
 }

 double mx[N+], dist[N+];
 int q[N+], vis[N+], dep[N+], dq[N+], fa[N+];

 bool cal(int o) {
     int maxdep = ;
     for (RE int I = path[o]; I; I = edge[I].next)
     if (!vis[edge[I].to]) {
         int head = , tail = ; q[tail] = edge[I].to, dep[q[]] = , dist[q[]] = edge[I].cost, fa[q[]] = o, ++tail;
         while (head < tail) {
         int now = q[head]; ++head;
         for (RE int i = path[now]; i; i = edge[i].next)
             if (fa[now] != edge[i].to && !vis[edge[i].to]) {
             q[tail] = edge[i].to, ++tail;
             dep[edge[i].to] = dep[now]+;
             dist[edge[i].to] = dist[now]+edge[i].cost;
             fa[edge[i].to] = now;
             }
         }
         int head1 = , tail1 = , now = maxdep;
         for (RE int i = ; i < tail; ++i) {
         int x = q[i];
         while (dep[x]+now >= L && now >= ) {
             while (head1 < tail1 && mx[dq[tail1-]] < mx[now]) --tail1;
             dq[tail1] = now; ++tail1, --now;
         }
         while (head1 < tail1 && dq[head1]+dep[x] > U) ++head1;
         if (head1 < tail1 && dist[x]+mx[dq[head1]] >= ) return true;
         }
         maxdep = Max(maxdep, dep[q[tail-]]);
         for (RE int i = ; i < tail; ++i) {
         fa[q[i]] = ; if (mx[dep[q[i]]] < dist[q[i]]) mx[dep[q[i]]] = dist[q[i]];
         }
     }
     for (RE int i = ; i <= maxdep; i++) mx[i] = -INF;
     return false;
 }
 bool solve(int o, int &num) {
     vis[o] = ;
     if (cal(o)) return true;
     for (RE int i = path[o]; i ;i = edge[i].next)
     if (!vis[edge[i].to]) {
         ++num; if (solve(root[num], num)) return true;
     }
     return false;
 }
 void pre(double key) {
     for (RE int i = ; i <= n; ++i) {
     edge[i<<].cost = edge[i<<].c-key, edge[(i<<)-].cost = edge[(i<<)-].c-key;
     vis[i] = , mx[i] = -INF;
     }
 }
 void work() {
     read(n), read(L), read(U);
     double L = , R = ;
     for (RE int i = ; i < n; ++i) {
     read(a), read(b), read(c);
     add(a, b, c), add(b, a, c); if (R < c) R = c;
     }
     PRE::main();
     while (R-L > eps) {
     double mid = (L+R)/.; pre(mid);
     int tot = ;
     if (solve(root[], tot)) L = mid;
     else R = mid;
     }
     printf("%.3lf\n", (L+R)/.);
 }
 int main() {
     work();
     return ;
 }