SPOJ 375 树链剖分
SPOJ 375
题目链接：
题意：
思路：
首先感谢这位博主http://blog.csdn.net/y990041769/article/details/40348013，基本照着打的。
昨晚打CF的时候遇到一道树链剖分的版题，今天顺便就学了一下……然后就学了一天。
这是一道树链剖分的版题。
树链剖分用于对一个带权值的树（边权或点权，边权可以通过下面代码类似的转化方式转成点权，但是查询的时候需要相应处理）进行查询操作（最值，和）。
首先树链剖分据说有很多种，目前只掌握了轻重链剖分的一种。
重链即子节点的子树中节点个数最多的那个子节点。如果有多个则任取一个。轻链是其他的所有链。
构建操作：
然后这样去构建一个线段树。因为每次都会先遍历一个点的重链，所以线段树的区间就是一段重链一段轻链的形式连接起来的。
查询操作：
对于树上两个点u、v，如果u和v不在一条重链上，则所在重链深度大的先更新（重链深度以重链顶端的那个起点为准）。当在一个重链上时，在对这个重链进行单独的查询操作。
修改操作：
线段树的单点修改。
源码：
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <string>
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int MAXN = 10000 + 5;
int son[MAXN], num[MAXN], dep[MAXN], fa[MAXN]; ///重链子节点、以其为根的子树节点个数、节点深度、结点的父节点
int tp[MAXN], cnt, id[MAXN]; ///所在重链的顶点、编号数、每个点的编号
vector<int>lin[MAXN]; ///每个点的相邻点
int n;
struct E ///存边
{
int u, v, val;
void read(){
scanf("%d%d%d", &u, &v, &val);
}
}e[MAXN];
void dfs1(int u, int f, int deep) ///简单深搜形成有根数，统计深度、父节点、子树的节点个数、重链子节点
{
fa[u] = f, dep[u] = deep, num[u] = 1;
son[u] = 0;
for(int i = 0 ; i < (int)lin[u].size() ; i++){
int v = lin[u][i];
if(v == f) continue;
dfs1(v, u, deep + 1);
num[u] += num[v];
if(num[son[u]] < num[v]) son[u] = v;
}
}
void dfs2(int u, int f) ///用于给结点编号，优先遍历重链子节点
{
id[u] = ++cnt;
tp[u] = f;
if(son[u]) dfs2(son[u], f);
for(int i = 0 ; i < (int)lin[u].size() ; i++){
int v = lin[u][i];
if(v == fa[u] || v == son[u]) continue;
dfs2(v, v);
}
}
int val[MAXN]; ///本题是边权，所以把边权赋给深度小的结点
struct Tree
{
int l, r, val;
void init(int _l, int _r){l = _l, r = _r;}
}tree[MAXN * 4];
void push_up(int o) ///线段树的操作
{
tree[o].val = max(tree[o*2].val, tree[o*2 + 1].val);
}
void build(int l, int r, int o) ///线段树的操作
{
tree[o].init(l, r);
if(l == r){
tree[o].val = val[l];
return;
}
int mid = (l + r) >> 1;
build(l, mid, o * 2);
build(mid + 1, r, o * 2 + 1);
push_up(o);
}
int query(int o, int l, int r) ///线段树的操作
{
if(tree[o].l >= l && tree[o].r <= r) return tree[o].val;
int mid = (tree[o].l + tree[o].r) >> 1;
int ans = 0;
if(l <= mid) ans = max(ans, query(o * 2, l, r));
if(mid < r) ans = max(ans, query(o * 2 + 1, l, r));
return ans;
}
void modify(int o, int u, int v) ///修改，线段树的操作
{
if(tree[o].l == tree[o].r){
tree[o].val = v;
return;
}
int mid = (tree[o].l + tree[o].r) / 2;
if(u <= mid) modify(o * 2, u, v);
else modify(o * 2 + 1, u, v);
push_up(o);
}
char op[200];
int solve(int u, int v) ///查询操作
{
int ans = 0;
int tp1 = tp[u], tp2 = tp[v];
while(tp1 != tp2){ ///在同一条重链时才退出
// printf("u = %d, v = %d, tp1 = %d, tp2 = %d\n", u, v, tp1, tp2);
if(dep[tp1] < dep[tp2]) swap(tp1, tp2), swap(u, v); ///设u为所在重链深度大的点
ans = max(ans, query(1, id[tp1], id[u]));
u = fa[tp1]; ///u更新为所在重链顶点 的父节点，再重新更新所在重链顶点的父节点
tp1 = tp[u];
// printf("ans = %d\n", ans);
}
// printf("u = %d, v = %d, tp1 = %d, tp2 = %d\n", u, v, tp1, tp2);
if(u == v) return ans;
if(dep[u] > dep[v]) swap(u, v);
ans = max(ans, query(1, id[son[u]], id[v])); ///由于点权是有边权转化来的，所以id[u]是不在u-v区间内的，id[son[u]]-v区间才是所求
return ans;
}
int main()
{
int T;
scanf("%d", &T);
while(T--){
scanf("%d", &n);
for(int i = 1 ; i <= n - 1 ; i++){
e[i].read();
lin[e[i].u].push_back(e[i].v);
lin[e[i].v].push_back(e[i].u);
}
cnt = 0;
dfs1(1, 0, 1);
dfs2(1, 1);
// val[1] = 1;
for(int i = 1 ; i <= n - 1 ; i++){
if(dep[e[i].u] < dep[e[i].v]) swap(e[i].u, e[i].v);
val[id[e[i].u]] = e[i].val;
}
build(1, cnt, 1);
while(~scanf("%s", op) && op[0] != 'D'){
int u, v;
scanf("%d%d", &u, &v);
if(op[0] == 'Q') printf("%d\n", solve(u, v));
else modify(1, id[e[u].u], v);
}
for(int i = 0 ; i <= n ; i++) lin[i].clear();
}
return 0;
}