Traffic Network in Numazu HDU - 6393（基环树）

Traffic Network in Numazu (HDU - 6393)

题意：给定一张\(n\)个点\(n\)条边的带权图。要求支持两种操作：

• \(0\ x\ y ：\)修改第\(x\)条边的权值为\(y\)。
• \(1\ x\ y ：\)查询\((x,y)\)的最短路。

题解：

\(n\)个点\(n\)条边，就是一颗基环树。我们可以拆掉基环树上的一条边，变为一棵树。那么两个点的最短路就是树上的距离和经过拆掉的边的距离，取最小值。

对于树上的距离，我们可以用线段树维护每个点到根节点的距离来求出。每次修改一条边的权值时，就把这条边以下的子树整体修改。

对于\((x,y)\)经过被拆掉的边\((u,v,len)\)的情况，我们可以在\((x, u)+(y, v)+len\)与\((x,v)+(y,u)+len\)取\(min\)。

最后把上面两种情况取\(min\)就是询问的答案。

代码：

#include <bits/stdc++.h>
#define fopi freopen("in.txt", "r", stdin)
#define fopo freopen("out.txt", "w", stdout)
using namespace std;
typedef long long LL;
typedef pair<int, LL> Pair;
const int inf = 0x3f3f3f3f;
const int maxn = 1e5 + 10;

LL d[maxn];
struct SegTree {
    struct Node {
        int l, r;
		LL sum, add;
    }t[maxn*4];

    void build(int id, int l, int r) {
        t[id].l = l, t[id].r = r;
        t[id].add = 0;
        if (l == r) {
            t[id].sum = d[t[id].l];
            return;
        }
        int mid = (l+r) / 2;
        build(id*2, l, mid);
        build(id*2+1, mid+1, r);
        t[id].sum = t[id*2].sum + t[id*2+1].sum;
    }

	void pushdown(int id) {
		if (t[id].add != 0) {
			t[id*2].add += t[id].add;
			t[id*2+1].add += t[id].add;
			int mid = (t[id].l + t[id].r) / 2;
			t[id*2].sum += t[id].add * (mid-t[id].l+1);
			t[id*2+1].sum += t[id].add * (t[id].r-mid);
			t[id].add = 0;
		}
	}

	void update(int id, int l, int r, LL val) {
		if (l <= t[id].l && r >= t[id].r) {
			t[id].add += val;
			t[id].sum += val * (t[id].r-t[id].l+1);
			return;
		}
		pushdown(id);
		int mid = (t[id].l + t[id].r) / 2;
		if (r <= mid) update(id*2, l, r, val);
		else if (l > mid) update(id*2+1, l, r, val);
		else update(id*2, l, mid, val), update(id*2+1, mid+1, r, val);
		t[id].sum = t[id*2].sum + t[id*2+1].sum;
	}

	LL query(int id, int x) {
		if (t[id].l == x && t[id].r == x) return t[id].sum;
		pushdown(id);
		int mid = (t[id].l + t[id].r) / 2;
		if (x <= mid) query(id*2, x); else query(id*2+1, x);
	}
}ST;

int fa[maxn][22], dep[maxn], dfn[maxn], dfr[maxn];
vector<Pair> V[maxn];
int depth, tot;

void init_lca(int x, int from) {
	dfn[x] = ++tot;
	dep[x] = dep[from] + 1;
	for (auto p : V[x]) {
        int y = p.first, l = p.second;
        if (y == from) continue;
		fa[y][0] = x;
		for (int j = 1; j <= depth; j++)
			fa[y][j] = fa[fa[y][j-1]][j-1];
		init_lca(y, x);
	}
	dfr[x] = tot;
}

void dfs(int x, int from) {
    for (auto p : V[x]) {
        int y = p.first, l = p.second;
        if (y == from) continue;
        d[dfn[y]] = d[dfn[x]] + l;
        dfs(y, x);
    }
}

int lca(int x, int y) {
	if (dep[x] > dep[y]) swap(x, y);
	for (int i = depth; i >= 0; i--)
		if (dep[fa[y][i]] >= dep[x]) y = fa[y][i];
	if (x == y) return x;
	for (int i = depth; i >= 0; i--)
		if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
	return fa[x][0];
}

LL dist(int x, int y) {
	int L = lca(x, y);
	LL d1 = ST.query(1, dfn[x]), d2 = ST.query(1, dfn[y]), d3 = ST.query(1, dfn[L]);
	return d1 + d2 - 2 * d3;
}

int T, n, m;
LL z[maxn];
int y[maxn];
int main() {
    scanf("%d", &T);
    for (int ca = 1; ca <= T; ca++) {
		scanf("%d%d", &n, &m);
		for (int i = 1; i <= n; i++) V[i].clear();

		for (int i = 1; i <= n-1; i++) {
            int x;
			scanf("%d%d%d", &x, &y[i], &z[i]);
			//其实这里应该按照dep的深度存第i条边的儿子节点。
			//所幸题目中没有逆序边，我也没wa。
			V[x].push_back({y[i], z[i]});
			V[y[i]].push_back({x, z[i]});
		}
		int xn, yn;
		scanf("%d%d%d", &xn, &yn, &z[n]);

		depth = 20, tot = 0;
		init_lca(1, 0);
		dfs(1, 0);
		ST.build(1, 1, n);
		for (int i = 1; i <= m; i++) {
			int op, x, val;
			scanf("%d%d%d", &op, &x, &val);
			if (op == 0) {
				if (x == n) { z[n] = val; continue; }
				LL deta = val - z[x];
				ST.update(1, dfn[y[x]], dfr[y[x]], deta);
				z[x] = val;
			}
			else {
                int fx = dfn[x], fy = dfn[val];
				LL d1 = dist(x, val),
					d2 = dist(x, xn) + dist(val, yn) + z[n],
					d3 = dist(x, yn) + dist(val, xn) + z[n];
				printf("%lld\n", min(d1, min(d2, d3)));
			}
		}
	}
}