Codeforces 1140G Double Tree 倍增 + dp

刚开始， 我以为两个点肯定是通过树上最短路径过去的， 无非是在两棵树之间来回切换， 这个可以用倍增 + dp

去维护它。 但是后来又发现， 它可以不通过树上最短路径过去， 我们考虑这样一种情况， 起点在奇树里面， 终点
在偶树里面， 然后这两个点最短路径里面点到对应点的距离都很大， 这种情况下我们就需要从别的地方绕过去， 这样

就不是走树上最短路径了， 但是如果我们将对应点的距离更新成最短距离， 上面这个倍增 + dp的方法就可行了， 所以

我们可以用最短路去更新对应点之间的距离， 将它变成最小值。

#include<bits/stdc++.h>
#define LL long long
#define fi first
#define se second
#define mk make_pair
#define PLL pair<LL, LL>
#define PLI pair<LL, int>
#define PII pair<int, int>
#define SZ(x) ((int)x.size())
#define ull unsigned long long

using namespace std;

const int N = 3e5 + ;
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int mod = ;
const double eps = 1e-;
const double PI = acos(-);

int n, q, depth[N];
LL d[N], gg[N], dp[N][][][];
int f[N][];
vector<pair<int, PLL>> G[N];
vector<PLI> E[N];

void dfs(int u, int fa, PLL dis) {
    depth[u] = depth[fa] + ;
    if(u > ) {
        f[u][] = fa;
        dp[u][][][] = min(dis.fi, dis.se + d[u] + d[fa]);
        dp[u][][][] = min(dis.se, dis.fi + d[u] + d[fa]);
        dp[u][][][] = min(dis.fi + d[fa], dis.se + d[u]);
        dp[u][][][] = min(dis.se + d[fa], dis.fi + d[u]);
        for(int i = ; i < ; i++) f[u][i] = f[f[u][i - ]][i - ];
        for(int i = ; i < ; i++) {
            int v = f[u][i - ];
            dp[u][][][i] = min(dp[u][][][i - ] + dp[v][][][i - ], dp[u][][][i - ] + dp[v][][][i - ]);
            dp[u][][][i] = min(dp[u][][][i - ] + dp[v][][][i - ], dp[u][][][i - ] + dp[v][][][i - ]);
            dp[u][][][i] = min(dp[u][][][i - ] + dp[v][][][i - ], dp[u][][][i - ] + dp[v][][][i - ]);
            dp[u][][][i] = min(dp[u][][][i - ] + dp[v][][][i - ], dp[u][][][i - ] + dp[v][][][i - ]);
        }
    }
    for(auto& e : G[u]) {
        if(e.fi == fa) continue;
        dfs(e.fi, u, e.se);
    }
}

int getLca(int u, int v) {
    if(depth[u] < depth[v]) swap(u, v);
    for(int i = ; i >= ; i--)
        if(depth[f[u][i]] >= depth[v]) u = f[u][i];
    if(u == v) return u;
    for(int i = ; i >= ; i--)
        if(f[u][i] != f[v][i]) u = f[u][i], v = f[v][i];
    return f[u][];
}

PLL calc(int u, int op1, int v) {
    int dis = depth[u] - depth[v];
    LL g[], tmp[];
    g[op1] = ;
    g[op1 ^ ] = d[u];
    for(int i = ; i >= ; i--) {
        if(dis >> i & ) {
            tmp[] = g[], tmp[] = g[];
            g[] = min(tmp[] + dp[u][][][i], tmp[] + dp[u][][][i]);
            g[] = min(tmp[] + dp[u][][][i], tmp[] + dp[u][][][i]);
            u = f[u][i];
        }
    }
    return mk(g[], g[]);
}

int main() {
    scanf("%d", &n);
    for(int i = ; i <= n; i++) scanf("%lld", &d[i]);
    for(int i = ; i <= n; i++) {
        int u, v; LL w1, w2;
        scanf("%d%d%lld%lld", &u, &v, &w1, &w2);
        G[u].push_back(mk(v, mk(w1, w2)));
        G[v].push_back(mk(u, mk(w1, w2)));
        E[u].push_back(mk(w1 + w2, v));
        E[v].push_back(mk(w1 + w2, u));
    }
    priority_queue<PLI, vector<PLI>, greater<PLI> > que;
    for(int i = ; i <= n; i++) {
        gg[i] = d[i];
        que.push(mk(d[i], i));
    }
    while(!que.empty()) {
        int u = que.top().se;
        LL val = que.top().fi;
        que.pop();
        if(val > gg[u]) continue;
        for(auto& e : E[u]) {
            if(gg[e.se] > val + e.fi) {
                gg[e.se] = val + e.fi;
                que.push(mk(gg[e.se], e.se));
            }
        }
    }
    for(int i = ; i <= n; i++) d[i] = gg[i];
    dfs(, , mk(, ));
    scanf("%d", &q);
    while(q--) {
        int u, v;
        scanf("%d%d", &u, &v);
        int op1 = (u & ) ?  : ;
        int op2 = (v & ) ?  : ;
        if(u & ) u = (u + ) >> ;
        else u >>= ;
        if(v & ) v = (v + ) >> ;
        else v >>= ;
        int Lca = getLca(u, v);
        PLL disu = calc(u, op1, Lca);
        PLL disv = calc(v, op2, Lca);
        printf("%lld\n", min(disu.fi + disv.fi, disu.se + disv.se));
    }
    return ;
}

/*

*/