洛谷P1399 快餐店

题意：在基环树上找一点，使得这个点到所有点的距离最大值最小。这个点可以在某条边上。

解：很容易想到找出直径然后/2对吧...这里的直径是指任意两点间最短距离的最大值。

然而我这个SB冥思苦想了半天之后想到了一个傻逼绝伦的做法：枚举边！

这个点一定在某条边上。

所以知道边的两端点最长延伸多长即可。

如果是子树里的边，很显然下面那个点就是子树内最长链。而上面那个点就是子树外最长链或深度 + 根节点在环上最长延伸距离。

如果是环上的边，就是两端点子树最长链或者环上延伸的最长距离。

值得注意的是，这两个"环上最长延伸距离"并不是一样的。

因为前者只有一个点在环上，没有别的环上的点跟它竞争。

而后者要跟环上另一个点相互竞争。所以还要分两种情况。

具体实现上，首先找环，然后每个子树做两次树形DP，第二次是二次扫描与换根法。

然后把环的信息提取出来DP，利用单调队列来求最长延伸距离，反正我写了4个......

最后枚举边判定。

反正就是仔细写，耐心Debug...

(为什么别人1k就能A而我要5k啊...)

#include <cstdio>
#include <algorithm>
#include <stack>
#include <cstring>

typedef long long LL;
const int N = 200010;

struct Edge {
    int nex, v;
    LL len;
}edge[N << 1]; int top = 1;

int e[N], n, cir[N], tc, p[N], head, tail, fr[N], nex[N], pre[N];
std::stack<int> S;
bool vis[N], is_cir[N];
LL d[N], len1[N], len2[N], lenup[N], dis[N], p2[N], sum[N], Long[N], Long_l[N], Long_r[N];

inline void add(int x, int y, LL z) {
    top++;
    edge[top].v = y;
    edge[top].len = z;
    edge[top].nex = e[x];
    e[x] = top;
    return;
}

void Df(int x, int f) {
    vis[x] = 1;
    S.push(x);
    for(int i = e[x]; i && !vis[0]; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == f) {
            continue;
        }
        if(vis[y]) {
            vis[0] = 1;
            while(x != y) {
                x = S.top();
                S.pop();
                is_cir[x] = 1;
                cir[++tc] = x;
            }
            return;
        }
        Df(y, x);
    }
    if(vis[0]) {
        return;
    }
    S.pop();
    vis[x] = 0;
    return;
}

void DFS_1(int x, int f, int aim) { // get d len1 len2
    if(!fr[x]) {
        fr[x] = fr[f];
    }
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == f || is_cir[y]) {
            if(cir[aim] == y) {
                dis[aim] = edge[i].len;
                nex[x] = y;
                pre[y] = x;
            }
            continue;
        }
        d[y] = d[x] + edge[i].len;
        DFS_1(y, x, aim);
        if(len1[x] < len1[y] + edge[i].len) {
            len2[x] = len1[x];
            len1[x] = len1[y] + edge[i].len;
        }
        else if(len2[x] < len1[y] + edge[i].len) {
            len2[x] = len1[y] + edge[i].len;
        }
    }
    return;
}

void DFS_2(int x, int f) {
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == f || is_cir[y]) {
            continue;
        }
        if(len1[y] + edge[i].len == len1[x]) {
            lenup[y] = std::max(lenup[x], len2[x]) + edge[i].len;
        }
        else {
            lenup[y] = std::max(lenup[x], len1[x]) + edge[i].len;
        }
        DFS_2(y, x);
    }
    return;
}

int main() {
    int x, y;
    LL z, Sum = 0;
    double ans = 0;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) {
        scanf("%d%d%lld", &x, &y, &z);
        add(x, y, z);
        add(y, x, z);
        ans += z;
    }
    Df(1, 0);

    for(int i = 1; i <= tc; i++) {
        fr[cir[i]] = cir[i];
        DFS_1(cir[i], 0, (i == tc ? 1 : i + 1));
        DFS_2(cir[i], 0);
        cir[tc + i] = cir[i];
    }
    for(int i = 1; i <= tc; i++) {
        Sum += dis[i];
        dis[tc + i] = dis[i];
    }
    for(int i = 1; i <= tc * 2; i++) {
        sum[i] = sum[i - 1] + dis[i];
    }

    LL dt = 0;
    head = 1;
    tail = 0;
    for(int i = 1; i <= tc * 2; i++) {
        // DP
        while(head <= tail && sum[i] - sum[p[head]] > Sum - (sum[i] - sum[p[head]])) {
            head++;
        }
        dt += dis[i];
        if(head <= tail) {
            Long[cir[i]] = std::max(Long[cir[i]], p2[head] + dt);
        }
        while(head <= tail && len1[cir[i]] - dt >= p2[tail]) {
            tail--;
        }
        p[++tail] = i;
        p2[tail] = len1[cir[i]] - dt;
    }
    head = 1;
    tail = 0;
    dt = 0;
    for(int i = tc * 2; i >= 1; i--) {
        while(head <= tail && sum[p[head]] - sum[i] > Sum - (sum[p[head]] - sum[i])) {
            head++;
        }
        dt += dis[i + 1];
        if(head <= tail) {
            Long[cir[i]] = std::max(Long[cir[i]], p2[head] + dt);
        }
        while(head <= tail && len1[cir[i]] - dt >= p2[tail]) {
            tail--;
        }
        p[++tail] = i;
        p2[tail] = len1[cir[i]] - dt;
    }
    // -------------------------------------------------------------------------------------------------------
    head = 1;
    tail = 0;
    dt = 0;
    dis[tc * 2 + 1] = dis[1];
    for(int i = 1; i <= tc * 2; i++) {
        // DP
        while(head <= tail && sum[i] - sum[p[head]] > Sum - (sum[i] - sum[p[head]] + dis[i + 1])) {
            head++;
        }
        dt += dis[i];
        if(head <= tail) {
            Long_l[cir[i]] = std::max(Long_l[cir[i]], p2[head] + dt);
        }
        while(head <= tail && len1[cir[i]] - dt >= p2[tail]) {
            tail--;
        }
        p[++tail] = i;
        p2[tail] = len1[cir[i]] - dt;
    }
    head = 1;
    tail = 0;
    dt = 0;
    for(int i = tc * 2; i >= 1; i--) {
        while(head <= tail && sum[p[head]] - sum[i] > Sum - (sum[p[head]] - sum[i - 1])) {
            head++;
        }
        dt += dis[i + 1];
        if(head <= tail) {
            Long_r[cir[i]] = std::max(Long_r[cir[i]], p2[head] + dt);
        }
        while(head <= tail && len1[cir[i]] - dt >= p2[tail]) {
            tail--;
        }
        p[++tail] = i;
        p2[tail] = len1[cir[i]] - dt;
    }
    //
    for(int i = 2; i <= top; i += 2) {
        int x = edge[i].v, y = edge[i ^ 1].v;
        LL a, b;
        if(is_cir[x] && is_cir[y]) {
            if(nex[y] == x) {
                std::swap(x, y);
            }
            a = std::max(Long_l[x], len1[x]);
            b = std::max(Long_r[y], len1[y]);
        }
        else {
            if(d[x] > d[y]) {
                std::swap(x, y);
            }
            a = len1[y];
            b = std::max(lenup[y] - edge[i].len, d[x] + Long[fr[x]]);
        }
        if(a < b) {
            std::swap(a, b);
        }
        if(a >= edge[i].len + b) {
            ans = std::min(ans, (double)a);
        }
        else {
            ans = std::min(ans, (a + b + edge[i].len) / 2.0);
        }
    }

    printf("%.1f", ans);
    return 0;
}