【bzoj3083】遥远的国度 树链剖分+线段树

题目描述

描述
zcwwzdjn在追杀十分sb的zhx，而zhx逃入了一个遥远的国度。当zcwwzdjn准备进入遥远的国度继续追杀时，守护神RapiD阻拦了zcwwzdjn的去路，他需要zcwwzdjn完成任务后才能进入遥远的国度继续追杀。

问题是这样的：遥远的国度有n个城市，这些城市之间由一些路连接且这些城市构成了一颗树。这个国度有一个首都，我们可以把这个首都看做整棵树的根，但遥远的国度比较奇怪，首都是随时有可能变为另外一个城市的。遥远的国度的每个城市有一个防御值，有些时候RapiD会使得某两个城市之间的路径上的所有城市的防御值都变为某个值。RapiD想知道在某个时候，如果把首都看做整棵树的根的话，那么以某个城市为根的子树的所有城市的防御值最小是多少。由于RapiD无法解决这个问题，所以他拦住了zcwwzdjn希望他能帮忙。但zcwwzdjn还要追杀sb的zhx，所以这个重大的问题就被转交到了你的手上。

输入

第1行两个整数n m，代表城市个数和操作数。
第2行至第n行，每行两个整数 u v，代表城市u和城市v之间有一条路。
第n+1行，有n个整数，代表所有点的初始防御值。
第n+2行一个整数 id，代表初始的首都为id。
第n+3行至第n+m+2行，首先有一个整数opt，如果opt=1，接下来有一个整数id，代表把首都修改为id；如果opt=2，接下来有三个整数p1 p2 v，代表将p1 p2路径上的所有城市的防御值修改为v；如果opt=3，接下来有一个整数 id，代表询问以城市id为根的子树中的最小防御值。

输出

对于每个opt=3的操作，输出一行代表对应子树的最小点权值。

样例输入

3 7
1 2
1 3
1 2 3
1
3 1
2 1 1 6
3 1
2 2 2 5
3 1
2 3 3 4
3 1

样例输出

1
2
3
4

---

题解

树链剖分+线段树

后两个操作是树剖的基本操作，而换根操作是我们需要重点解决的。

首先换根不能真的换，也不能使用LCT（因为不能维护子树），我们需要思考换根之后子树的变化。

设所求为x的子树，当前的根为root，那么分3种情况讨论：

1.root=x，那么子树直接就是整棵树。

2.root在原来x的父树中，即root不在原来x的子树中，那么当前x的子树就是原来x的子树，因为遍历序是相同的。

3.root在原来x的子树中。此时我们思考：按照遍历序，应该是先遍历root，然后遍历到x的儿子中是root的祖先的节点（我们称它为rs），再遍历x，最后遍历其它节点。这样在x之前遍历到的只有原来rs的子树，这不算在当前x的子树内，其余的均为x当前的子树。那么由于子树在dfs序上是连续的一段区间，查询x当前的子树就相当于在线段树上查询[1,l-1]和[r+1,n]的部分。

所以树剖之后记录子树范围，如果是第三种情况再求一个rs即可。

如何求rs？其实和树剖求LCA差不多。

考虑root是怎么跳到x的，最后一步只有两种情况：从重链跳到x、从轻链跳到x。从重链的情况，rs就是x的重儿子，在dfs时顺便记录一下就好了；从轻链的情况，最后一步一定是从x的儿子跳过来的，所以跳过来前的那个节点就是rs。

说了这么多其实代码真心简单。

最后：本题有毒。1280MB的空间限制各种误导开nlogn大数组QAQ，权值“<=2^31”爆int，需要unsigned int QAQ

#include <cstdio>
#include <algorithm>
#define N 100010
#define lson l , mid , x << 1
#define rson mid + 1 , r , x << 1 | 1
using namespace std;
int head[N] , to[N << 1] , next[N << 1] , cnt , n;
int fa[N] , deep[N] , si[N] , bl[N] , pos[N] , tot , son[N] , last[N];
unsigned v[N] , minn[N << 2] , tag[N << 2];
void add(int x , int y)
{
	to[++cnt] = y , next[cnt] = head[x] , head[x] = cnt;
}
void dfs1(int x)
{
	int i;
	si[x] = 1;
	for(i = head[x] ; i ; i = next[i])
		if(to[i] != fa[x])
			fa[to[i]] = x , deep[to[i]] = deep[x] + 1 , dfs1(to[i]) , si[x] += si[to[i]];
}
void dfs2(int x , int c)
{
	int k = 0 , i;
	bl[x] = c , pos[x] = ++tot;
	for(i = head[x] ; i ; i = next[i])
		if(to[i] != fa[x] && si[to[i]] > si[k])
			k = to[i];
	if(k)
	{
		son[x] = k , dfs2(k , c);
		for(i = head[x] ; i ; i = next[i])
			if(to[i] != fa[x] && to[i] != k)
				dfs2(to[i] , to[i]);
	}
	last[x] = tot;
}
void pushup(int x)
{
	minn[x] = min(minn[x << 1] , minn[x << 1 | 1]);
}
void pushdown(int x)
{
	if(tag[x]) minn[x << 1] = minn[x << 1 | 1] = tag[x << 1] = tag[x << 1 | 1] = tag[x] , tag[x] = 0;
}
void build(int l , int r , int x)
{
	if(l == r)
	{
		minn[x] = v[l];
		return;
	}
	int mid = (l + r) >> 1;
	build(lson) , build(rson) , pushup(x);
}
void update(int b , int e , unsigned a , int l , int r , int x)
{
	if(b <= l && r <= e)
	{
		minn[x] = tag[x] = a;
		return;
	}
	pushdown(x);
	int mid = (l + r) >> 1;
	if(b <= mid) update(b , e , a , lson);
	if(e > mid) update(b , e , a , rson);
	pushup(x);
}
unsigned query(int b , int e , int l , int r , int x)
{
	if(b > e) return 0xffffffff;
	if(b <= l && r <= e) return minn[x];
	pushdown(x);
	int mid = (l + r) >> 1;
	unsigned ans = 0xffffffff;
	if(b <= mid) ans = min(ans , query(b , e , lson));
	if(e > mid) ans = min(ans , query(b , e , rson));
	return ans;
}
int find(int x , int s)
{
	while(bl[s] != bl[x])
	{
		if(fa[bl[s]] == x) return bl[s];
		s = fa[bl[s]]; 
	}
	return son[x];
}
void modify(int x , int y , unsigned a)
{
	while(bl[x] != bl[y])
	{
		if(deep[bl[x]] < deep[bl[y]]) swap(x , y);
		update(pos[bl[x]] , pos[x] , a , 1 , n , 1) , x = fa[bl[x]];
	}
	if(deep[x] > deep[y]) swap(x , y);
	update(pos[x] , pos[y] , a , 1 , n , 1);
}
int main()
{
	int m , i , x , y , root , opt , t;
	unsigned z;
	scanf("%d%d" , &n , &m);
	for(i = 1 ; i < n ; i ++ ) scanf("%d%d" , &x , &y) , add(x , y) , add(y , x);
	dfs1(1) , dfs2(1 , 1);
	for(i = 1 ; i <= n ; i ++ ) scanf("%u" , &v[pos[i]]);
	build(1 , n , 1);
	scanf("%d" , &root);
	while(m -- )
	{
		scanf("%d%d" , &opt , &x);
		if(opt == 1) root = x;
		else if(opt == 2) scanf("%d%u" , &y , &z) , modify(x , y , z);
		else if(pos[root] == pos[x]) printf("%u\n" , minn[1]);
		else if(pos[root] < pos[x] || pos[root] > last[x]) printf("%u\n" , query(pos[x] , last[x] , 1 , n , 1));
		else t = find(x , root) , printf("%u\n" , min(query(1 , pos[t] - 1 , 1 , n , 1) , query(last[t] + 1 , n , 1 , n , 1)));
	}
	return 0;
}