luogu P4114 Qtree1（树链剖分）

题目

给定一棵n个节点的树，有两个操作：

• CHANGE i ti 把第i条边的边权变成ti

• QUERY a b 输出从a到b的路径中最大的边权，当a=b的时候，输出0

输入输出格式
输入格式：

• 第一行输入一个n，表示节点个数

• 第二行到第n行每行输入三个数，ui，vi，wi，分别表示 ui，vi有一条边，边权是wi

• 第n+1行开始，一共有不定数量行，每一行分别有以下三种可能

• CHANGE，QUERY同题意所述

• DONE表示输入结束

输出格式：

• 对于每个QUERY操作，输出一个数，表示a b之间边权最大值

输入输出样例
输入样例#1：

3
1 2 1
2 3 2
QUERY 1 2
CHANGE 1 3
QUERY 1 2
DONE

输出样例#1：

1
3

提交地址

题解

• emmm这题一看就是树链剖分qwq
• 但我们平常都是用线段树维护点权，那么这道题我们可以把两点边权转到深度较深的点的点权上。
• 注意两点之间的$lca$不能被算入答案
• 关于如何避开$lca$我们在询问时假设$x,y$为两点，且在同一重链上，设$dep[x]<dep[y]$，答案查询区间为$[idx[x]+1,y]$，因为$idx[x]$为$lca$，且重链内标号连续。（$dep$记录深度，$idx$记录重新标号后每个节点的标号）

code

#include <map> 
#include <set> 
#include <list> 
#include <cmath> 
#include <deque> 
#include <stack> 
#include <queue> 
#include <cstdio> 
#include <cctype> 
#include <vector> 
#include <string> 
#include <cstring> 
#include <iomanip> 
#include <complex> 
#include <iostream> 
#include <algorithm> 
#include <functional> 
using namespace std; 
const int maxn = 100000 + 100; 

template <class T> inline void read(T &s) { 
	s = 0; T w = 1, ch = getchar(); 
	while (!isdigit(ch)) { if (ch == '-') w = -1; ch = getchar(); }
	while (isdigit(ch)) { s = (s << 1) + (s << 3) + (ch ^ 48); ch = getchar(); }
	s *= w; 
}

int n, tot, cnt; 
int lin[maxn], tree[maxn * 4], from[maxn], to[maxn]; 
int siz[maxn], fat[maxn], dep[maxn], val[maxn]; 
int son[maxn], idx[maxn], top[maxn], pre[maxn]; 
struct edge {
	int next, to, dis; 
} e[maxn << 1]; 
inline void add(int from, int to, int dis) {
	e[++tot].to = to; 
	e[tot].dis = dis; 
	e[tot].next = lin[from]; 
	lin[from] = tot; 
}

void dfs1(int u, int fa, int depth) {
	siz[u] = 1; 
	fat[u] = fa; 
	dep[u] = depth; 
	int maxson = -1; 
	for (int i = lin[u]; i; i = e[i].next) {
		int v = e[i].to; 
		if (v == fa) continue; 
		pre[v] = e[i].dis; 
		dfs1(v, u, depth + 1); 
		siz[u] += siz[v]; 
		if (siz[v] > maxson) {
			maxson = siz[v]; 
			son[u] = v; 
		}
	}
}

void dfs2(int u, int tp) {
	top[u] = tp; 
	idx[u] = ++cnt; 
	val[cnt] = pre[u]; 
	if (!son[u]) return ; 
	dfs2(son[u], tp); 
	for (int i = lin[u]; i; i = e[i].next) {
		int v = e[i].to; 
		if (!idx[v]) 
			dfs2(v, v); 
	}
}

void build(int p, int l, int r) {
	if (l == r) { tree[p] = val[l]; return ; }
	int mid = (l + r) >> 1; 
	build(p<<1, l, mid); 
	build(p<<1|1, mid + 1, r); 
	tree[p] = max(tree[p<<1], tree[p<<1|1]);  
}

void modify(int p, int l, int r, int x, int v) {
	if (l == r) { 
		tree[p] = v; 
		return ; 
	}
	int mid = (l + r) >> 1; 
	if (x <= mid) modify(p<<1, l, mid, x, v); 
	else modify(p<<1|1, mid + 1, r, x, v); 
	tree[p] = max(tree[p<<1], tree[p<<1|1]); 
}

int query(int p, int l, int r, int x, int y) {
	if (x > y) return 0; 
	if (x <= l && r <= y) return tree[p]; 
	int ret = 0; 
	int mid = (l + r) >> 1; 
	if (x <= mid) ret = max(ret, query(p<<1, l, mid, x, y)); 
	if (y > mid) ret = max(ret, query(p<<1|1, mid + 1, r, x, y)); 
	return ret; 
}

int TreeQuery(int x, int y) {
	if (x == y) return 0; 
	int ret = 0; 
	while (top[x] ^ top[y]) {
		if (dep[top[x]] < dep[top[y]]) swap(x, y); 
		ret = max(ret, query(1, 1, n, idx[top[x]], idx[x])); 
		x = fat[top[x]]; 
	}
	if (dep[x] > dep[y]) swap(x, y); 
	ret = max(ret, query(1, 1, n, idx[x] + 1, idx[y])); 
	return ret; 
}

int main() {
	read(n); 
	for (int i = 1; i < n; ++i) {
		int u, v, w; 
		read(u), read(v), read(w); 
		from[i] = u, to[i] = v; 
		add(u, v, w); 
		add(v, u, w); 
	}

	dfs1(1, 0, 1); 
	dfs2(1, 1); 
	build(1, 1, n); 

	char ch[10]; int x, y; 
	while (1) {
		scanf("%s", ch); 
		if (ch[0] == 'D') return 0; 
		else if (ch[0] == 'Q') {
			read(x), read(y); 
			printf("%d\n", TreeQuery(x, y)); 
		}
		else if (ch[0] == 'C') {
			read(x), read(y); 
			int u = from[x], v = to[x]; 
			if (fat[v] == u) swap(u, v); 
			modify(1, 1, n, idx[u], y); 
		}
	}
	return 0; 
}