[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 = 100000;
const int INF = ~0u>>1;
const double eps = 4e-4;
void read(int &x) {
    char ch; x = 0;
    ch = getchar(); while (ch < '0' || ch > '9') ch = getchar();
    while (ch >= '0' && ch <= '9') x = (x<<1)+(x<<3)+ch-48, ch = getchar();
}

int n, L, U, a, b, c;
struct tt {
    int to, next;
    double cost, c;
}edge[(N<<1)+5];
int path[N+5], top;
int root[N+5];
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+5], mx[N+5], minsize, rt, vis[N+5], 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] = 1, mx[o] = 0;
    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, 0), get_root(o, o, 0);
    root[++tot] = rt, vis[rt] = 1;
    for (RE int i = path[rt]; i; i = edge[i].next)
        if (!vis[edge[i].to]) work(edge[i].to);
    }
    void main() {work(1); }
}

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

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