LOJ#2553 暴力写挂

题意：给定两棵树T1，T2，求d₁[x] + d₁[y] - d₁[lca₁(x, y)] - d₂[lca₂(x, y)]的最大值。

解：考虑把上面这个毒瘤东西化一下。发现它就是T1中x，y到根的路径并 - T2中x，y到根的路径交。

也就是T1中的一个三叉状路径和T2中lca到根的路径。

根据情报中心的套路，把这个东西 * 2，发现就是d₁[x] + d₁[y] + dis₁(x, y) - d₂[x] - d₂[y] + dis₂(x, y)

令val[i] = d₁[i] - d₂[i]，我们就要令val[x] + val[y] + dis₁(x, y) + dis₂(x, y)最大。

考虑在T1上边分治，这样的话dis₁(x, y) = d[x] + d[y] + e。e是分治边的长度。

在T2上把T1这次分治的点全部提出来建虚树。我们不妨把每个T1的节点挂到对应的虚树节点上，边权为val[x] + d[x]，那么我们就是要在虚树上挂的点中找到两个异色节点，使得它们距离最远。

此时我们有一个非常优秀的O(n)DFS算法......但是我就是SB中的SB中的SB，把这个问题搞成了nlogn。这个解决之后本题就做完了。为了卡常用了优秀的zkw线段树。

#include <bits/stdc++.h>

#define forson(x, i) for(register int i = e[x]; i; i = edge[i].nex)

#define add(x, y, z) edge[++tp].v = y; edge[tp].len = z; edge[tp].nex = e[x]; e[x] = tp
#define ADD(x, y) EDGE[++TP].v = y; EDGE[TP].nex = E[x]; E[x] = TP

typedef long long LL;
const int N = 800010;
const LL INF = 4e18;

inline char gc() {
    static char buf[N], *p1(buf), *p2(buf);
    if(p1 == p2) p2 = (p1 = buf) + fread(buf, 1, N, stdin);
    return p1 == p2 ? EOF : *p1++;
}

template <class T> inline void read(T &x) {
    x = 0;
    register char c(gc());
    bool f(false);
    while(c < '0' || c > '9') {
        if(c == '-') f = true;
        c = gc();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - 48;
        c = gc();
    }
    if(f) x = (~x) + 1;
    return;
}

struct Edge {
    int nex, v;
    bool vis;
    LL len;
}edge[N << 1], EDGE[N << 1]; int tp = 1, TP;

int pw[N << 1], n, e[N], Cnt, _n, small, root, imp[N], K, use[N], Time, stk[N], top, E[N], RT, POS[N], NUM, SIZ[N], ID[N], vis[N], siz[N];
LL val[N], ans = -INF, d[N], VAL[N], H[N], C[N], W[N];
std::vector<int> G[N];
std::vector<LL> Len[N];

namespace seg2 {
    LL large[N << 2];
    void build(int l, int r, int o) {
        if(l == r) {
            large[o] = VAL[ID[r]];
            //if(F) printf("p = %d x = %d val = %lld 
", r, ID[r], VAL[ID[r]]);
            return;
        }
        int mid((l + r) >> 1);
        build(l, mid, o << 1);
        build(mid + 1, r, o << 1 | 1);
        large[o] = std::max(large[o << 1], large[o << 1 | 1]);
        return;
    }
    LL getMax(int L, int R, int l, int r, int o) {
        if(L <= l && r <= R) {
            return large[o];
        }
        LL ans = -INF;
        int mid((l + r) >> 1);
        if(L <= mid) ans = getMax(L, R, l, mid, o << 1);
        if(mid < R) ans = std::max(ans, getMax(L, R, mid + 1, r, o << 1 | 1));
        return ans;
    }
}

namespace seg {
    LL large[N << 2];
    int lm;
    inline void build(int n) {
        lm = 1; n += 2;
        while(lm < n) lm <<= 1;
        large[lm] = -INF;
        for(register int i = 1; i <= n; i++) {
            large[i + lm] = VAL[ID[i]];
        }
        for(register int i = n + 1; i < lm; i++) {
            large[i + lm] = -INF;
        }
        for(int i = lm - 1; i >= 1; i--) {
            large[i] = std::max(large[i << 1], large[i << 1 | 1]);
        }
        return;
    }
    inline LL getMax(int L, int R) {
        LL ans = -INF;
        for(int s = lm + L - 1, t = lm + R + 1; s ^ t ^ 1; s >>= 1, t >>= 1) {
            if(t & 1) {
                ans = std::max(ans, large[t ^ 1]);
            }
            if((s & 1) == 0) {
                ans = std::max(ans, large[s ^ 1]);
            }
        }
        return ans;
    }
}

namespace t1 {
    int e[N], pos2[N], ST[N << 1][20], num2, deep[N];
    LL d[N];
    Edge edge[N << 1]; int tp;
    void DFS_1(int x, int f) {
        deep[x] = deep[f] + 1;
        pos2[x] = ++num2;
        ST[num2][0] = x;
        forson(x, i) {
            int y(edge[i].v);
            if(y == f) continue;
            d[y] = d[x] + edge[i].len;
            DFS_1(y, x);
            ST[++num2][0] = x;
        }
        return;
    }
    inline void prework() {
        for(register int j(1); j <= pw[num2]; j++) {
            for(register int i(1); i + (1 << j) - 1 <= num2; i++) {
                if(deep[ST[i][j - 1]] < deep[ST[i + (1 << (j - 1))][j - 1]]) {
                    ST[i][j] = ST[i][j - 1];
                }
                else {
                    ST[i][j] = ST[i + (1 << (j - 1))][j - 1];
                }
            }
        }
        return;
    }
    inline int lca(int x, int y) {
        x = pos2[x], y = pos2[y];
        if(x > y) std::swap(x, y);
        int t(pw[y - x + 1]);
        if(deep[ST[x][t]] < deep[ST[y - (1 << t) + 1][t]]) {
            return ST[x][t];
        }
        else {
            return ST[y - (1 << t) + 1][t];
        }
    }
    inline LL dis(int x, int y) {
        return d[x] + d[y] - 2 * d[lca(x, y)];
    }
}

void rebuild(int x, int f) {
    int temp(0);
    for(register int i(0); i < G[x].size(); i++) {
        int y = G[x][i];
        LL len = Len[x][i];
        if(y == f) continue;
        if(!temp) {
            add(x, y, len);
            add(y, x, len);
            temp = x;
        }
        else if(i == G[x].size() - 1) {
            add(temp, y, len);
            add(y, temp, len);
        }
        else {
            add(temp, ++Cnt, 0);
            add(Cnt, temp, 0);
            temp = Cnt;
            add(temp, y, len);
            add(y, temp, len);
        }
        d[y] = d[x] + len;
        rebuild(y, x);
    }
    return;
}

void getroot(int x, int f) {
    siz[x] = 1;
    //printf("getroot : x = %d 
", x);
    forson(x, i) {
        int y(edge[i].v);
        if(y == f || edge[i].vis) continue;
        getroot(y, x);
        if(small > std::max(siz[y], _n - siz[y])) {
            small = std::max(siz[y], _n - siz[y]);
            root = i;
        }
        siz[x] += siz[y];
    }
    //printf("siz %d = %d 
", x, siz[x]);
    return;
}

void DFS_1(int x, int f, int flag) {
    siz[x] = 1;
    //printf("x = %d d = %lld 
", x, d[x]);
    if(!flag && x <= n) {
        imp[++K] = x;
        vis[x] = Time;
        //if(F) printf("vis %d = Time 
", x);
    }
    else if(flag && x <= n) {
        imp[++K] = x;
    }
    forson(x, i) {
        int y(edge[i].v);
        if(y == f || edge[i].vis) continue;
        d[y] = d[x] + edge[i].len;
        DFS_1(y, x, flag);
        siz[x] += siz[y];
    }
    return;
}

inline void work(int x) {
    if(use[x] == Time) return;
    use[x] = Time;
    E[x] = 0;
    return;
}

inline bool cmp(const int &a, const int &b) {
    return t1::pos2[a] < t1::pos2[b];
}

inline void build_t() {
    std::sort(imp + 1, imp + K + 1, cmp);
    K = std::unique(imp + 1, imp + K + 1) - imp - 1;
    work(imp[1]);
    stk[top = 1] = imp[1];
    for(register int i(2); i <= K; i++) {
        int x = imp[i], y = t1::lca(x, stk[top]);
        work(x); work(y);
        while(top > 1 && t1::pos2[y] <= t1::pos2[stk[top - 1]]) {
            ADD(stk[top - 1], stk[top]);
            top--;
        }
        if(y != stk[top]) {
            ADD(y, stk[top]);
            stk[top] = y;
        }
        stk[++top] = x;
    }
    while(top > 1) {
        ADD(stk[top - 1], stk[top]);
        top--;
    }
    RT = stk[top];
    return;
}

void dfs_2(int x) {
    //printf("dfs_2 x = %d 
", x);
    SIZ[x] = 1;
    POS[x] = ++NUM;
    ID[NUM] = x;
    if(vis[x] == Time) VAL[x] = t1::d[x] + val[x] + d[x];
    else VAL[x] = -INF;
    /*if(F && x == 3) {
        printf("VAL 3 = %lld + %lld + %lld 
", t1.d[x], val[x], d[x]);
    }*/
    C[x] = VAL[x];
    for(register int i(E[x]); i; i = EDGE[i].nex) {
        int y = EDGE[i].v;
        dfs_2(y);
        SIZ[x] += SIZ[y];
        C[x] = std::max(C[x], C[y]);
    }
    //if(F) printf("x = %d VAL = %lld  C = %lld 
", x, VAL[x], C[x]);
    return;
}

void dfs_3(int x, int f) {
    if(f) {
        /// cal H[x]
        H[x] = seg::getMax(POS[f], POS[x] - 1);
        if(POS[x] + SIZ[x] < POS[f] + SIZ[f]) {
            H[x] = std::max(H[x], seg::getMax(POS[x] + SIZ[x], POS[f] + SIZ[f] - 1));
        }
        W[x] = std::max(W[f], H[x] - 2 * t1::d[f]);
    }
    else {
        H[x] = W[x] = -INF;
    }
    //if(F) printf("x = %d H = %lld W = %lld 
", x, H[x], W[x]);
    for(register int i(E[x]); i; i = EDGE[i].nex) {
        int y(EDGE[i].v);
        dfs_3(y, x);
    }
    return;
}

void DFS_4(int x, int f, LL v) {
    /// ask
    if(x <= n) {
        VAL[x] = t1::d[x] + val[x] + d[x] + v;
        ans = std::max(ans, VAL[x] + W[x]);
        ans = std::max(ans, VAL[x] + C[x] - 2 * t1::d[x]);
    }
    forson(x, i) {
        int y(edge[i].v);
        if(y == f || edge[i].vis) continue;
        DFS_4(y, x, v);
    }
    return;
}

void e_div(int x) {
    if(_n == 1) {
        ans = std::max(ans, val[x] << 1);
        return;
    }
    small = N;
    getroot(x, 0);
    edge[root].vis = edge[root ^ 1].vis = 1;

    x = edge[root].v;
    int y = edge[root ^ 1].v;
    if(siz[x] < _n - siz[x]) std::swap(x, y);

    //if(F) printf("div %d %d  _n = %d 
", x, y, _n);

    ///
    d[x] = d[y] = 0;
    TP = K = 0;
    Time++;
    DFS_1(x, 0, 0);
    DFS_1(y, 0, 1);
    /// build virtue trEE
    build_t();
    //printf("v_t build over 
");
    /// prework
    NUM = 0;
    dfs_2(RT);
    //printf("dfs_2 over 
");
    seg::build(NUM);
    //printf("seg build over 
");
    dfs_3(RT, 0);
    DFS_4(y, 0, edge[root].len);

    //if(F) printf("ans = %d 
", ans);

    _n = siz[x];
    e_div(x);
    _n = siz[y];
    e_div(y);
    return;
}

int main() {

    W[0] = -INF;
    read(n);
    LL z;
    for(register int i(1), x, y; i < n; i++) {
        read(x); read(y); read(z);
        G[x].push_back(y);
        G[y].push_back(x);
        Len[x].push_back(z);
        Len[y].push_back(z);
    }
    for(register int i(1), x, y; i < n; i++) {
        read(x); read(y); read(z);
        t1::edge[++t1::tp].v = y;
        t1::edge[t1::tp].len = z;
        t1::edge[t1::tp].nex = t1::e[x];
        t1::e[x] = t1::tp;
        t1::edge[++t1::tp].v = x;
        t1::edge[t1::tp].len = z;
        t1::edge[t1::tp].nex = t1::e[y];
        t1::e[y] = t1::tp;
    }
    for(register int i = 2; i <= n * 2; i++) {
        pw[i] = pw[i >> 1] + 1;
    }
    t1::DFS_1(1, 0);
    t1::prework();

    Cnt = n;
    rebuild(1, 0);
    for(register int i(1); i <= n; i++) {
        val[i] = d[i] - t1::d[i];
    }
    /// ans = val[i] + val[j] + t0.dis(i, j) + t1.dis(i, j);
    _n = Cnt;
    e_div(1);

    printf("%lld
", ans >> 1);
    return 0;
}

讲一下我的做法。考虑到两个点的距离是d + d - 2 * lca，我们预处理某一颜色的节点，然后枚举另一个颜色的所有点。

由于开店的启发，我们可以把每个点往上更新链，然后每个点往上查询链。

进而发现，查询全是静态的，所以可以预处理出一个点到根路径上的max，变成单点查询。

设VAl[x]为挂上的节点x的深度。C[x]为x的子树中的最大VAL值。

设H[x]为（subtree(fa[x]) subtree(x)的最大VAL值） - 2 * VAL[x]，W[x]为x到根路径上的最大H值。

那么对于一个点x，它只要和W[x]，C[x] - 2 * VAL[x]拼起来就能得到跟它相关的最远点对距离了。

复杂度在于求H[x]的时候使用DFS序 + RMQ，写了一个log。所以总复杂度是nlog²n。

---

有个T1是链且v > 0的部分分。这里我们发现T1的路径并变成了max(d₁[x], d₁[y])，于是考虑枚举T2中每个点作为lca，要求两个点在其子树中，且max(d₁[x], d₁[y])最大。显然维护一个子树最大值就好了。实测有80分呢......

还有个迭代乱搞是随机选一个起点，每次迭代找到一个点与之贡献最大并更新那个点为新的起点。多来几次。这样也有80分呢......

比写正解不知道高到哪里去了...