[BZOJ 3786] 星系探索

BZOJ传送门

题目描述

物理学家小C的研究正遇到某个瓶颈。

他正在研究的是一个星系，这个星系中有$n$个星球，其中有一个主星球(方便起见我们默认其为$1$号星球)，其余的所有星球均有且仅有一个依赖星球。主星球没有依赖星球。

我们定义依赖关系如下：若星球$a$的依赖星球是$b$,则有星球$a$依赖星球$b$.此外，依赖关系具有传递性，即若星球$a$依赖星球$b$,星球$b$依赖星球$c$,则有星球$a$依赖星球$c$.

对于这个神秘的星系中，小C初步探究了它的性质，发现星球之间的依赖关系是无环的。并且从星球$a$出发只能直接到达它的依赖星球$b$.

每个星球$i$都有一个能量系数$w_i$.小C想进行若干次实验，第$i$次实验，他将从飞船上向星球$d_i$发射一个初始能量为$0$的能量收集器，能量收集器会从星球$d_i$开始前往主星球，并收集沿途每个星球的部分能量，收集能量的多少等于这个星球的能量系数。

但是星系的构成并不是一成不变的，某些时刻，星系可能由于某些复杂的原因发生变化。

有些时刻，某个星球能量激发，将使得所有依赖于它的星球以及他自己的能量系数均增加一个定值。还有可能在某些时刻，某个星球的依赖星球会发生变化，但变化后依然满足依赖关系是无环的。

现在小C已经测定了时刻$0$时每个星球的能量系数,以及每个星球(除了主星球之外)的依赖星球。接下来的$m$个时刻，每个时刻都会发生一些事件。其中小C可能会进行若干次实验，对于他的每一次实验，请你告诉他这一次实验能量收集器的最终能量是多少。

输入输出格式

输入格式

第一行一个整数$n$,表示星系的星球数。

接下来$n-1$行每行一个整数,分别表示星球$2-n$的依赖星球编号。

接下来一行$n$个整数，表示每个星球在时刻$0$时的初始能量系数$w_i$.

接下来一行一个整数$m$,表示事件的总数。

事件分为以下三种类型。

(1)"Q di"表示小C要开始一次实验,收集器的初始位置在星球$d_i$.

(2)"C xi yi"表示星球$x_i$的依赖星球变为了星球$y_i$.

(3)"F pi qi"表示星球$p_i$能量激发，常数为$q_i$.

输出格式

对于每一个事件类型为$Q$的事件，输出一行一个整数，表示此次实验的收集器最终能量。

输入输出样例

输入样例#1：

3
1
1
4 5 7
5
Q 2
F 1 3
Q 2
C 2 3
Q 2

输出样例#1：

9
15
25

提示

$n\le 100000,m\le 300000,1<d_i,x_i\le n,w_i,q_i\le 100000$.保证操作合法。注意$w_i\ge 0$

解题分析

有换父节点操作， 可以用$LCT$， 然而还有个子树加…

换个思路， 因为只求到根节点的路径和， 可以用入栈出栈序加一个前缀和做到， 所以等于我们求出入栈出栈序后每次换父亲就是挪一个区间到父节点入栈位置后， 子树加就是入栈到出栈位置区间加， 可以用$splay$或$fhqTreap$维护。

代码如下：

#include <cstdio>
#include <cmath>
#include <cstring>
#include <cctype>
#include <climits>
#include <cstdlib>
#include <cassert>
#include <iostream>
#include <algorithm>
#include <vector>
#define R register
#define IN inline
#define W while
#define ls tree[now].son[0]
#define rs tree[now].son[1]
#define dad tree[now].fat
#define gc getchar()
#define ll long long
#define MX 200500
template <class T>
IN void in(T &x)
{
	x = 0; R char c = gc;
	for (; !isdigit(c); c = gc);
	for (;  isdigit(c); c = gc)
	x = (x << 1) + (x << 3) + c - 48;
}
template <class T> IN T max(T a, T b) {return a > b ? a : b;}
template <class T> IN T min(T a, T b) {return a < b ? a : b;}
IN int rd() {return (1ll * rand() * rand() % INT_MAX + 1ll * rand() * rand() % INT_MAX) % INT_MAX;}
int n, q, tot, root, cnt, top;
int sta[MX], eul[MX], head[MX], val[MX];
struct Node {int son[2], avai, typ, siz, key, fat; ll val, sum, tag;} tree[MX];
struct Edge {int to, nex;} edge[MX];
IN void add(R int from, R int to) {edge[++cnt] = {to, head[from]}, head[from] = cnt;}
IN void pushdown(R int now)
{
	if (tree[now].tag)
	{
		tree[ls].tag += tree[now].tag;
		tree[ls].sum += 1ll * tree[ls].avai * tree[now].tag;
		tree[ls].val += tree[now].tag * tree[ls].typ;
		tree[rs].tag += tree[now].tag;
		tree[rs].sum += 1ll * tree[rs].avai * tree[now].tag;
		tree[rs].val += tree[now].tag * tree[rs].typ;
		tree[now].tag = 0;
	}
}
IN void pushup(R int now)
{
	tree[now].sum = tree[ls].sum + tree[rs].sum + tree[now].val;
	tree[now].avai = tree[ls].avai + tree[rs].avai + tree[now].typ;
	tree[now].siz = tree[ls].siz + tree[rs].siz + 1;
}
IN void split(R int now, R int tar, int &x, int &y)
{
	if (now == 0) return x = y = 0, void();
	pushdown(now);
	if (tree[ls].siz >= tar)
	{
		y = now, split(ls, tar, x, ls);
		if (tree[y].son[0]) tree[tree[y].son[0]].fat = y;
		if (tree[y].son[1]) tree[tree[y].son[1]].fat = y;
	}
	else
	{
		x = now, split(rs, tar - tree[ls].siz - 1, rs, y);
		if (tree[x].son[0]) tree[tree[x].son[0]].fat = x;
		if (tree[x].son[1]) tree[tree[x].son[1]].fat = x;
	}
	pushup(now);
}
IN int merge(R int x, R int y)
{
	if ((!x) || (!y)) return x | y;
	pushdown(x), pushdown(y);
	if (tree[x].key < tree[y].key)
	{
		tree[x].son[1] = merge(tree[x].son[1], y);
		if (tree[x].son[0]) tree[tree[x].son[0]].fat = x;
		if (tree[x].son[1]) tree[tree[x].son[1]].fat = x;
		pushup(x); return x;
	}
	else
	{
		tree[y].son[0] = merge(x, tree[y].son[0]);
		if (tree[y].son[0]) tree[tree[y].son[0]].fat = y;
		if (tree[y].son[1]) tree[tree[y].son[1]].fat = y;
		pushup(y); return y;
	}
}
IN int Getpos(R int tar, R int p)
{
	R int now = tree[tar].fat, las = tar, ret = 1;
	if (tree[tar].son[0]) ret += tree[tree[tar].son[0]].siz;
	W (now)
	{
		if (rs == las) ret += 1 + tree[ls].siz;
		las = now, now = dad;
	}
	return ret;
}
int build()
{
	int now, las;
	for (R int i = 1; i <= tot; ++i)
	{
		if (eul[i] < 0)
		{
			now = -eul[i] + n;
			tree[now].siz = 1;
			tree[now].typ = tree[now].avai = -1;
			tree[now].val = tree[now].sum = -val[-eul[i]];
		}
		else
		{
			now = eul[i];
			tree[now].siz = 1;
			tree[now].typ = tree[now].avai = 1;
			tree[now].val = tree[now].sum = val[eul[i]];
		}
		tree[now].key = rd(); las = 0;
		W (top && tree[sta[top]].key > tree[now].key)
		las = sta[top--], pushup(las);
		if (top) tree[sta[top]].son[1] = now, dad = sta[top];
		tree[now].son[0] = las, tree[las].fat = now, sta[++top] = now;
	}
	W (top) pushup(sta[top--]);
	return sta[1];
}
void DFS(R int now)
{
	eul[++tot] = now;
	for (R int i = head[now]; i; i = edge[i].nex) DFS(edge[i].to);
	eul[++tot] = -now;
}
char str[5];
int main(void)
{
	in(n);
	int tar, par, x, y, z, del;
	for (R int i = 2; i <= n; ++i) in(par), add(par, i);
	for (R int i = 1; i <= n; ++i) in(val[i]);
	DFS(1); root = build();
	in(q);
	W (q--)
	{
		scanf("%s", str);
		if (str[0] == 'Q')
		{
			in(tar);
			int res = Getpos(tar, root);
			split(root, res, x, y);
			printf("%lld\n", tree[x].sum);
			root = merge(x, y);
			tree[root].fat = 0;
		}
		else if (str[0] == 'C')
		{
			in(tar), in(par);
			int st = Getpos(tar, root);
			int ed = Getpos(tar + n, root);
			split(root, ed, x, y), split(x, st - 1, x, z);
			tree[x].fat = tree[y].fat = tree[z].fat = 0;
            //清零父节点， 否则向上跳的时候不能在根节点停下来
			x = merge(x, y);
			int Pos = Getpos(par, x);
			split(x, Pos, x, y);
			root = merge(merge(x, z), y);
			tree[root].fat = 0;
		}
		else
		{
			in(tar), in(del);
			int st = Getpos(tar, root);
			int ed = Getpos(tar + n, root);
			split(root, ed, x, y), split(x, st - 1, x, z);
			tree[z].tag += del;
			tree[z].val += tree[z].typ * del;
			tree[z].sum += 1ll * tree[z].avai * del;
			root = merge(merge(x, z), y);
			tree[root].fat = 0;
		}
	}
}