树链剖分+线段树 bzoj1036 树的统计

一棵树上有n个节点，编号分别为1到n，每个节点都有一个权值w。我们将以下面的形式来要求你对这棵树完成一些操作： I. CHANGE u t : 把结点u的权值改为t II. QMAX u v: 询问从点u到点v的路径上的节点的最大权值 III. QSUM u v: 询问从点u到点v的路径上的节点的权值和 注意：从点u到点v的路径上的节点包括u和v本身

Input

输入的第一行为一个整数n，表示节点的个数。接下来n – 1行，每行2个整数a和b，表示节点a和节点b之间有一条边相连。接下来n行，每行一个整数，第i行的整数wi表示节点i的权值。接下来1行，为一个整数q，表示操作的总数。接下来q行，每行一个操作，以“CHANGE u t”或者“QMAX u v”或者“QSUM u v”的形式给出。 对于100％的数据，保证1<=n<=30000，0<=q<=200000；中途操作中保证每个节点的权值w在-30000到30000之间。

Output

对于每个“QMAX”或者“QSUM”的操作，每行输出一个整数表示要求输出的结果。

Sample Input

4
1 2
2 3
4 1
4 2 1 3
12
QMAX 3 4
QMAX 3 3
QMAX 3 2
QMAX 2 3
QSUM 3 4
QSUM 2 1
CHANGE 1 5
QMAX 3 4
CHANGE 3 6
QMAX 3 4
QMAX 2 4
QSUM 3 4

Sample Output

4
1
2
2
10
6
5
6
5
16

树链剖分：

需要进行两次深搜，第一次dfs求出每个节点的siz[],dep[].

代码如下：

void dfs1(int x)
{
	siz[x] = 1;
	for (int i = head[x];i;i = e[i].next)
	{
		if (e[i].to == fa[x]) continue;
		dep[e[i].to] = dep[x] + 1;
		fa[e[i].to] = x;
		dfs1(e[i].to);
		siz[x] += siz[e[i].to];
	}
}

dfs2要做的就是：将重链连接起来并顺着重链重新给节点标号，这样标出来的新序列就是线段树里的区间了

 

void dfs2(int x, int top)
{
	int k = 0;sz++;
	pos[x] = sz;//节点x的新标号
	bl[x] = top;//连接重链
	for (int i = head[x];i;i = e[i].next)
		if (dep[e[i].to] > dep[x] && siz[e[i].to] > siz[k])
			k = e[i].to;//选择子树的重儿子继承重链
	if (k == 0) return;
	dfs2(k, top);
	for (int i = head[x];i;i = e[i].next)
		if (dep[e[i].to] > dep[x] && k != e[i].to)
			dfs2(e[i].to, e[i].to);//轻边下面的节点自己就是重链的顶端
}

 这样树链就剖分好了，要让我们求x, y最短路劲上的和与极值，这个就由线段树来处理

int solvesum(int x, int y)
{
	int sum = 0;
	while (bl[x] != bl[y])//一直跳到两个在同一条链上
	{
		if (dep[bl[x]] < dep[bl[y]]) swap(x, y);//操作之后x的链顶深度更深
		sum += querysum(1, pos[bl[x]], pos[x]);//返回x所在重链上的最大值
		x = fa[bl[x]];//x跳到重链顶点的父亲
	}
	if (pos[x] > pos[y]) swap(x, y);//x在y之前
	sum += querysum(1, pos[x], pos[y]);
	return sum;
}

完整代码如下：

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#define inf 0x7fffffff
#define N 30005
#define M 60005
using namespace std;
int n, q, cnt, sz;
int v[N], dep[N], siz[N], head[N], fa[N];
int pos[N], bl[N];
struct data { int to, next; }e[M];
struct tree { int l, r, mx, sum; }t[4*N];
void insert(int u, int v)
{
	e[++cnt].to = v;e[cnt].next = head[u];head[u] = cnt;
	e[++cnt].to = u;e[cnt].next = head[v];head[v] = cnt;
}

void init()
{
	scanf("%d", &n);
	for (int i = 1;i < n;i++)
	{
		int x, y;
		scanf("%d%d", &x, &y);
		insert(x, y);
	}
	for (int i = 1;i <= n;i++) scanf("%d", &v[i]);
}

void dfs1(int x)//求出siz dep fa 
{
	siz[x] = 1;
	for (int i = head[x];i;i = e[i].next)
	{
		if (e[i].to == fa[x])continue;
		dep[e[i].to] = dep[x] + 1;
		fa[e[i].to] = x;
		dfs1(e[i].to);
		siz[x] += siz[e[i].to];
	}
}

void dfs2(int x, int chain)//将重边连接成重链，按重链重新给节点标号
{
	int k = 0;sz++;
	pos[x] = sz;//x节点在线段树中的标号
	bl[x] = chain;
	for (int i = head[x];i;i = e[i].next)
		if (dep[e[i].to] > dep[x] && siz[e[i].to] > siz[k])
			k = e[i].to;//选择子树最大的儿子继承重链
	if (k == 0) return;
	dfs2(k, chain);
	for (int i = head[x];i;i = e[i].next)
		if (dep[e[i].to] > dep[x] && k != e[i].to)
			dfs2(e[i].to, e[i].to);
}

void build(int k, int l, int r)
{
	t[k].l = l;t[k].r = r;
	if (l == r) return;
	int mid = (l + r) / 2;
	build(k << 1, l, mid);
	build(k << 1 | 1, mid + 1, r);
}
void modify(int k, int x, int y)
{
	int l = t[k].l, r = t[k].r;
	int mid = (l + r) / 2;
	if (l == r) { t[k].sum = t[k].mx = y;return; }
	if (x <= mid) modify(k << 1, x, y);
	else modify(k << 1 | 1, x, y);
	t[k].sum = t[k << 1].sum + t[k << 1 | 1].sum;
	t[k].mx = max(t[k << 1].mx, t[k << 1 | 1].mx);
}
int querysum(int k, int x, int y)
{
	int l = t[k].l, r = t[k].r, mid = (l + r) / 2;
	if (l == x && r == y) return t[k].sum;
	if (y <= mid) return querysum(k << 1, x, y);
	else if (x > mid) return querysum(k << 1 | 1, x, y);
	else { return querysum(k << 1, x, mid) + querysum(k << 1 | 1, mid + 1, y); }
}
int querymx(int k, int x, int y)
{
	int l = t[k].l, r = t[k].r, mid = (l + r) >> 1;
	if (l == x && y == r)return t[k].mx;
	if (y <= mid)return querymx(k << 1, x, y);
	else if (x > mid)return querymx(k << 1 | 1, x, y);
	else { return max(querymx(k << 1, x, mid), querymx(k << 1 | 1, mid + 1, y)); }
}

int solvesum(int x, int y)
{
	int sum = 0;
	while (bl[x] != bl[y])//一直跳到两个在同一条链上
	{
		if (dep[bl[x]] < dep[bl[y]]) swap(x, y);//操作之后x的链顶深度更深
		sum += querysum(1, pos[bl[x]], pos[x]);//返回x所在重链上的最大值
		x = fa[bl[x]];//x跳到重链顶点的父亲
	}
	if (pos[x] > pos[y]) swap(x, y);//x在y之前
	sum += querysum(1, pos[x], pos[y]);
	return sum;
}

int solvemx(int x, int y)
{
	int mx = -inf;
	while (bl[x] != bl[y])
	{
		if (dep[bl[x]] < dep[bl[y]]) swap(x, y);
		mx = max(mx, querymx(1, pos[bl[x]], pos[x]));
		x = fa[bl[x]];
	}//退出循环时x,y在同一条重链上
	if (pos[x] > pos[y]) swap(x, y);
	mx = max(mx, querymx(1, pos[x], pos[y]));
	return mx;
}
int main()
{
	init();
	dfs1(1);
	dfs2(1, 1);
	build(1, 1, n);
	for (int i = 1;i <= n;i++)
		modify(1, pos[i], v[i]);
	scanf("%d", &q);
	while (q--)
	{
		char op[10];
		scanf("%s", op);
		int x, y;
		scanf("%d%d", &x, &y);
		if (op[0] == 'C')
			modify(1, pos[x], y);
		else if (op[1] == 'M')
			printf("%d\n", solvemx(x, y));
		else printf("%d\n", solvesum(x, y));
	}
	return 0;
}