Codeforces 838B Diverging Directions（线段树 DFS）

题意：一棵N个点2*(n-1)条边的树，前n-1条边是以1为根节点生成的外向树的边，后n-1条边时没个点指向根节点1的边，边上都有权值，有q个操作：

1 i w 将第i条边的权值修改为w

2 u v查询u到v的最短路

思路：先看2操作， 如果u是v的祖先，那么直接计算u到v的距离即可，因为不会有比这条路更优的了；如果u不是v的祖先，根据题意分析，那么只有通过u回到根节点，再从根节点去v这样的路径。从根节点去v只有一条路可走（不重复走边的情况下），设为d1，而u回到根节点，却可以通过u -> u的某个子孙 -> 1这样的路径，就要查询这样一个最小值，加上根节点到v的路径距离就是答案。 再注意到，对于1操作， 如果是外向树的边，假设第i条边是（u - > v），那么对于根节点为v的子树，改变的值都有影响，所以容易想到生成dfs序列，序列的值是 1到节点的距离再加上该节点到根节点的距离（也就是一个环），如果是对外向树的边修改，就更新v对应的子树中所有节点的距离；如果不是，那么就只更新单个节点的距离， 这样对于查询的时候，

1：u是v的祖先， ans = (d[v] -to_node[v]) - (d[u] -to_node[u]) （d[i]是dfs序列中1 -> i -> 1的距离， to_node[i]是i -> 1的距离）

2：u不是v的祖先， ans = min { d[i] } - (d[u] - to_node[u])  + d[v] - to_node[v] （i是u的子孙）

画图理解一下更好。

#include<cstdio>
#include<cstring>
#include<vector>
#include<iostream>
#include<algorithm>
typedef long long ll;
const int maxn = 2e5 + 10;
const ll INF = 1e18;
using namespace std;

typedef pair<int, int> P;
int L[maxn], R[maxn], wt[maxn];
int n, q, k, son[maxn];
int to_node[2 * maxn], to_node_number[2 * maxn];
ll dis[maxn];
vector<P> G[2 * maxn];
int anc[maxn][20], p[maxn], deep[maxn];

void dfs(int u, int fa, ll d, int dep) {
    L[u] = k; p[u] = fa;
    dis[k++] = d + to_node[u]; deep[u] = dep;
    for(int i = 0; i < G[u].size(); i++) {
        int v = G[u][i].first, w = G[u][i].second;
        if(u == fa) continue;
        dfs(v, u, d + w, dep + 1);
    }
    R[u] = k - 1;
}

void preprocess() {
    for(int i = 1; i <= n; i++) {
        anc[i][0] = p[i];
        for(int j = 1; (1 << j) < n; j++) anc[i][j] = -1;
    }
    for(int j = 1; (1 << j) < n; j++) {
        for(int i = 1; i <= n; i++) {
            if(anc[i][j - 1] == -1) continue;
            int a = anc[i][j - 1];
            anc[i][j] = anc[a][j - 1];
        }
    }
}

int LCA(int p, int q) {
    int lg;
    if(deep[p] < deep[q]) swap(p, q);
    for(lg = 1; (1 << lg) <= deep[p]; lg++); lg--;
    int ans = 0;
    for(int i = lg; i >= 0; i--) {
        if(deep[p] - (1 << i) >= deep[q])
            p = anc[p][i];
    }
    if(p == q) return p;
    return -1;
}

ll C[maxn * 4], lazy[maxn * 4];
int m, ql, qr;
void build(int o, int l, int r) {
    if(l == r) { C[o] = dis[l]; return ; }
    int mid = (l + r) >> 1;
    build(o << 1, l, mid);
    build(o << 1 | 1, mid + 1, r);
    C[o] = min(C[o << 1], C[o << 1 | 1]);
}

void push_down(int o) {
    C[o << 1] += lazy[o];
    C[o << 1 | 1] += lazy[o];
    lazy[o << 1] += lazy[o];
    lazy[o << 1 | 1] += lazy[o];
    lazy[o] = 0;
}

ll query(int o, int l, int r) {
    if(l >= ql && r <= qr) return C[o];
    if(l > qr || r < ql) return INF;
    push_down(o);
    int mid = (l + r) >> 1;
    ll p1 = query(o << 1, l, mid);
    ll p2 = query(o << 1 | 1, mid + 1, r);
    C[o] = min(C[o << 1], C[o << 1 | 1]);
    return min(p1, p2);
}

void update(int o, int l, int r) {
    if(l >= ql && r <= qr) { C[o] += m; lazy[o] += m; return ; }
    if(l > qr || r < ql) return ;
    int mid = (l + r) >> 1;
    push_down(o);
    update(o << 1, l, mid);
    update(o << 1 | 1, mid + 1, r);
    C[o] = min(C[o << 1], C[o << 1 | 1]);
}

int main() {
    while(scanf("%d %d", &n, &q) != EOF) {
        k = 0;
        memset(C, 0, sizeof C);
        memset(lazy, 0, sizeof lazy);
        for(int i = 0; i < 2 * maxn; i++) G[i].clear();
        for(int i = 1; i <= 2 * n - 2; i++) {
            int u, v, w;
            scanf("%d %d %d", &u, &v, &w);
            if(i <= n - 1) {
                G[u].push_back(P(v, w));
                son[i] = v; wt[v] = w;
            }
            else {
                to_node[u] = w;
                to_node_number[i] = u;
            }
        }
        dfs(1, 0, 0, 1);
        preprocess();
        build(1, 0, k - 1);
        while(q--) {
            int op, u, v;
            scanf("%d %d %d", &op, &u, &v);
            if(op == 1) {
                if(u <= n - 1) {
                    int sn = son[u], wi = wt[sn];
                    ql = L[sn]; qr = R[sn];
                    m = v - wi;
                    update(1, 0, k - 1);
                    wt[sn] = v;
                } else {
                    int vt = to_node_number[u];
                    ql = qr = L[vt];
                    m = v - to_node[vt];
                    to_node[vt] = v;
                    update(1, 0, k - 1);
                }
            } else {
                ll ans, ton = to_node[u];
                int nx = LCA(u, v);
                if(nx == u) {
                    ql = qr = L[u];
                    ll wu = query(1, 0, k - 1) - to_node[u];
                    ql = qr = L[v];
                    ll wv = query(1, 0, k - 1) - to_node[v];
                    ans = wv - wu;
                } else {
                    ql = L[u]; qr = R[u];
                    ll d1 = query(1, 0, k - 1);
                    ql = qr = L[u];
                    d1 -= (query(1, 0, k - 1) - to_node[u]);

                    ql = qr = L[v];
                    ll d2 = query(1, 0, k - 1);
                    //printf("to_node == %d\n", to_node[v]);
                    ans = d1 + d2 - to_node[v];
                }
                printf("%lld\n", ans);
            }
        }
    }
    return 0;
}