Codeforces 835F Roads in the Kingdom

题目传送门

　　传送点I

　　传送点II

　　传送点III

题目大意

 　　给定一颗基环树，要求删去其中一条边，使得剩下的图形是一棵树，并且最长路的长度最短，求最长路的最短长度。

　　路径可以分为两部分：跨过环 和 在树内部。

　　要删除一条边，使图形变为一棵树，那么只能删去环上的一条边，因此，我们无法改变第二部分的路径，但是可以改变第一部分。

　　对于第二部分可以通过两次搜索或者树形动态规划解决。

　　对于第一部分，考虑枚举删去环上的一条边。但是发现仍然不太方便处理，因为不好维护环上的信息。仍然考虑剖环成链。

　　假设环的大小为$k$，从剖点开始依次将所有点标号1到$k$。

　　当一条边被删除后，第二部分可能成为答案的情况有两种：

1. 不跨过剖点和被删边的路径
2. 跨过剖点但不经过被删边的路径

　　因此考虑维护一些数组。

1. 在$1, 2, cdots, i$及其所在的树中的最长路。
2. 从$1$开始，到$1, 2, cdots, i$及其所在的树中的最长路。
3. 在$k, k - 1, cdots, i$及其所在的树中的最长路。
4. 从$k$开始，到$k, k - 1, cdots, i$及其所在的树中的最长路。

　　这四个部分都可以线性预处理出来。然后枚举删掉的环边就能统计第一部分的答案。

Code

/**
 * Codeforces
 * Problem#835F
 * Accepted
 * Time: 155ms
 * Memory: 27100k
 */ 
#include <bits/stdc++.h>
#ifndef WIN32
#define Auto "%lld"
#else
#define Auto "%I64d"
#endif
using namespace std;
typedef bool boolean;

typedef class Edge {
    public:
        int ed, nx, w;

        Edge(int ed = 0, int nx = 0, int w = 0):ed(ed), nx(nx), w(w) {    }
}Edge;

typedef class MapManager {
    public:
        int ce;
        int* h;
        Edge* es;

        MapManager() {    }
        MapManager(int n, int m):ce(-1) {
            h = new int[(n + 1)];
            es = new Edge[(m + 1)];
            memset(h, -1, sizeof(int) * (n + 1));
        }

        void addEdge(int u, int v, int w) {
            es[++ce] = Edge(v, h[u], w);
            h[u] = ce;
        }

        Edge& operator [] (int pos) {
            return es[pos];
        }
}MapManager;

#define ll long long

const signed ll llf = (signed ll) ((~0ull) >> 1);

int n;
int ccir, cc;
MapManager g;
stack<int> s;
boolean *vis, *icir;
int *cir, *nw;
ll *ap[2], *cp[2], *dep, *dis;

inline void init() {
    scanf("%d", &n);
    vis = new boolean[(n + 1)];
    icir = new boolean[(n + 1)];
    cir = new int[(n + 1)];
    nw = new int[(n + 1)];
    dep = new ll[(n + 1)];
    dis = new ll[(n + 1)];
    for (int i = 0; i < 2; i++) {
        ap[i] = new ll[(n + 1)];
        cp[i] = new ll[(n + 1)];
    }
    g = MapManager(n, n << 1);
    memset(vis, false, sizeof(boolean) * (n + 1));
    memset(icir, false, sizeof(boolean) * (n + 1));
    for (int i = 1, u, v, w; i <= n; i++) {
        scanf("%d%d%d", &u, &v, &w);
        g.addEdge(u, v, w);
        g.addEdge(v, u, w);
    }
}

boolean getLoop(int p, int fa) {
    if (vis[p]) {
        ccir = 0;
        int cur = 0;
        do {
            cur = s.top();
            s.pop();
            icir[cur] = true;
            cir[ccir++] = cur;
            cc = ccir - 1;
        } while (cur != p);
        return true;
    }
    vis[p] = true;
    s.push(p);
    for (int i = g.h[p]; ~i; i = g[i].nx) {
        int e = g[i].ed;
        if (e == fa)    continue;
        if (getLoop(e, p)) {
            if (icir[p]) {
                nw[cc] = g[i].w;
                cc = (cc + 1) % ccir;
            }
            return true;
        } 
    }
    s.pop();
    return false;
}

void dfs(int p, int fa, ll dep, int& fn, ll& fd) {
    if (dep > fd)
        fd = dep, fn = p;
    for (int i = g.h[p]; ~i; i = g[i].nx) {
        int e = g[i].ed;
        if (e == fa || icir[e])    continue;
        dfs(e, p, dep + g[i].w, fn, fd);
    }
}

inline void solve() {
    getLoop(1, 0);
    ll fixedd = 0;
//    for (int i = 0; i < ccir; i++)
//        cerr << cir[i] << " ";
//    cerr << endl;
//    for (int i = 0; i < ccir; i++)
//        cerr << nw[i] << " ";
//    cerr << endl;
    for (int i = 0, fn, fbn; i < ccir; i++) {
        fn = -1, dep[i] = 0;
        dep[i] = 0, dfs(cir[i], 0, 0, fn, dep[i]);
        if (~fn)
            icir[cir[i]] = false, dfs(fn, 0, 0, fbn, fixedd), icir[cir[i]] = true;
    }
    dis[0] = 0;
    for (int i = 1; i < ccir; i++)
        dis[i] = nw[i - 1];
    for (int i = 1; i < ccir; i++)
        dis[i] += dis[i - 1];
    ll mi = dep[0];
    ap[0][0] = -llf, cp[0][0] = dep[0];
    for (int i = 1; i < ccir; i++) {
        ap[0][i] = max(ap[0][i - 1], dep[i] + dis[i] + mi);
        mi = max(mi, dep[i] - dis[i]);
        cp[0][i] = max(cp[0][i - 1], dep[i] + dis[i]);
    }
    mi = dep[ccir - 1] + dis[ccir - 1];
    ap[1][ccir - 1] = -llf, cp[1][ccir - 1] = dep[ccir - 1];
    for (int i = ccir - 2; ~i; i--) {
        ap[1][i] = max(ap[1][i + 1], dep[i] - dis[i] + mi);
        mi = max(mi, dep[i] + dis[i]);
        cp[1][i] = max(cp[1][i + 1], dep[i] + dis[ccir - 1] - dis[i]);
    }
    ll ans = ap[0][ccir - 1];
    for (int i = 0; i < ccir - 1; i++)
        ans = min(max(max(ap[0][i], ap[1][i + 1]), cp[0][i] + cp[1][i + 1] + nw[ccir - 1]), ans);
    printf(Auto, max(ans, fixedd));
}

int main() {
    init();
    solve();
    return 0;
}