[ACNOI2022]唯一可做之题

题目

题目背景
连续两天写 $\text{LCT}+\text{ddp}$，今天一看，感觉仍然 $\mathtt{d}\mathtt{d}\mathtt{p}$，加之我已将时间尽耗于 $T_1,T_2$，终弃之而去。

可惜，它杀了个回马枪，这次的 $\mathtt{d}\mathtt{d}\mathtt{p}$ 形式非常特别。可惜，我无法跳出我的思维模式，也因此无法超越 $\mathsf{D}\mathsf{D}(\mathsf{X}\mathsf{Y}\mathsf{X})$ 。可惜，$\mathsf{O}\mathsf{U}\mathsf{Y}\mathsf{E}$ 从来不会犯下这种错误，轻取 $AC$ 。

题目描述
给出 $n$ 个点的树，点有点权 $v_i$，进行 $q$ 次操作，有三种类型：单点加 $v_i$，子树加 $v_i$，查询 ${\sum }_{1⩽i<j⩽n}[\text{lca}(i,j)=x]\cdot v_i{v}_j$，输出结果对 $2^{63}$ 取模。

数据范围与约定
$\max (n,q)⩽2\times 10^5$，但我们应该可以做到更好。修改量 $\Delta v\in [0,10^9]$，初值 $v_i\in [0,10^9]$，但这不重要。

思路

本以为是一个矩阵较为庞大的 $\mathtt{d}\mathtt{d}\mathtt{p}$ 。现在看来，做的无用功实在太多。记 $S_x$ 为 $x$ 子树内的 $v_i$ 之和，则
$$ans(x)=\frac{1}{2}\left(S_x^2-v_x^2-\sum _{y\in {\text{son}}_x}{S}_y^2\right)$$

值得注意的是 $ans(x)$ 并不用于转移，只是求出答案，所以 不需要放入矩阵。同理 $S_x^2$ 也不用放入矩阵，说白了，只有 $S_x$ 在上传。

重链剖分后，对每个点直接维护轻儿子的 $S_y^2$ 之和；自己的 $S_x$ 也要维护。求答案，就用已知的 $\sum S_y^2$ 与重儿子 $S_w$ 与自己的 $S_x,v_x$ 直接计算。用 $\text{unsigned long long}$ 可以算出取模 $2^{64}$ 的结果，最后除以 $2$ 就刚好。

子树修改对于 $\mathtt{d}\mathtt{d}\mathtt{p}$ 并不友好。立刻更新所有点的信息比较困难时，尝试懒标记。把 “子树加” 留在所操作的节点上（子树的根）。对于该点之上的祖先，难以 “看见” 该点的标记，最好提前更新；对于该点子树内的点，则可以查询时再考虑——找出当前子树被哪些懒标记给 “覆盖”，即这些标记作用于整棵子树。那么实际需要求出 ${\sum }_{y\in {\text{son}}_x}(S_y+{\text{size}}_y\cdot d{)}^2={\sum }_y{S}_y^2+2d{\sum }_y{S}_y\cdot {\text{size}}_y+d^2{\sum }_y{\text{size}}_y^2$ 。

那么，能够再算出 $\sum S_y\cdot {\text{size}}_y$ 就好，毕竟 $\sum {\text{size}}_y^2$ 是定值。存下来即可。当然，是不考虑子树外的懒标记的值。

不需要矩阵，也不再需要线段树维护重链了，因为 $S_x$ 具有现实意义，可以用 $\mathtt{d}\mathtt{f}\mathtt{n}$ 上的线段树 $\mathcal{O}(\log n)$ 直接查询。代码实现也比较容易，时间复杂度 $\mathcal{O}(n\log n+q\log n)$，其中 $n\log n$ 也可优化为 $\mathcal{O}(n)$，但没必要。

代码

#include <cstdio> // JZM yydJUNK!!!
#include <iostream> // XJX yyds!!!
#include <algorithm> // XYX yydLONELY!!!
#include <cstring> // (the STRONG long for LONELINESS)
#include <cctype> // ZXY yydSISTER!!!
using namespace std;
# define rep(i,a,b) for(int i=(a); i<=(b); ++i)
# define drep(i,a,b) for(int i=(a); i>=(b); --i)
typedef long long llong;
inline int readint(){
	int a = 0, c = getchar(), f = 1;
	for(; !isdigit(c); c=getchar())
		if(c == '-') f = -f;
	for(; isdigit(c); c=getchar())
		a = (a<<3)+(a<<1)+(c^48);
	return a*f;
}
inline void writeint(const uint64_t &x){
	if(x > 9) writeint(x/10);
	putchar(int(x%10)^48);
}

const int MAXN = 200005;
struct Edge{ int to, nxt; };
Edge e[MAXN<<1]; int head[MAXN], cntEdge;
inline void addEdge(int a, int b){
	e[cntEdge].to = b, e[cntEdge].nxt = head[a];
	head[a] = cntEdge ++;
}
# define _go(i,x) for(int i=head[x]; ~i; i=e[i].nxt)

unsigned int siz[MAXN];
int heavy[MAXN], fa[MAXN];
void scan(int x){
	siz[x] = 1; _go(i,x){
		fa[e[i].to] = x, scan(e[i].to);
		siz[x] += siz[e[i].to];
		if(siz[e[i].to] > siz[heavy[x]])
			heavy[x] = e[i].to; // node indice
	}
}

unsigned int lsiz[MAXN], v[MAXN];
int dfn[MAXN], ed[MAXN], top[MAXN], dfsClock;
uint64_t lig[MAXN][2], me[MAXN];
void dfs(int x, int bel){
	dfn[x] = ++ dfsClock, top[x] = bel;
	if(heavy[x]) dfs(heavy[x],bel), me[x] = me[heavy[x]];
	_go(i,x) if(e[i].to != heavy[x]){
		dfs(e[i].to,e[i].to), me[x] += me[e[i].to];
		lsiz[x] += siz[e[i].to]*siz[e[i].to];
		lig[x][0] += me[e[i].to]*siz[e[i].to];
		lig[x][1] += me[e[i].to]*me[e[i].to];
	}
	me[x] += v[x], ed[x] = dfsClock;
}

/// @brief add value of @p x by @p qv
void update_chain(int x, const uint64_t &qv){
	for(x=top[x]; x!=1; x=top[fa[x]]){
		lig[fa[x]][1] += (qv+(me[x]<<1))*qv;
		lig[fa[x]][0] += qv*siz[x], me[x] += qv;
	}
}

/// @brief add on range and query a single point (for calculate tag)
namespace Tagger{
	uint64_t c[MAXN];
	void modify(int ql, int qr, const unsigned &qv){
		for(int i=ql; i<=dfsClock; i+=(i&-i)) c[i] += qv;
		for(int i=qr+1; i<=dfsClock; i+=(i&-i)) c[i] -= qv;
	}
	uint64_t query(int qid){
		uint64_t res = 0;
		for(int i=qid; i; i&=(i-1)) res += c[i];
		return res;
	}
}
/// @brief add on range and query a range sum (for calculate S_x)
namespace SgTree{
	uint64_t one[MAXN], two[MAXN];
	void _modify(int qid, const uint64_t &qv){
		const uint64_t tmp = qv*unsigned(qid);
		for(int i=qid; i<=dfsClock; i+=(i&-i))
			one[i] += qv, two[i] += tmp;
	}
	uint64_t _query(int qid){
		uint64_t res = 0, sum = 0;
		for(int i=qid; i; i&=(i-1))
			res += two[i], sum += one[i];
		return sum*unsigned(qid+1u)-res;
	}
	void modify(int ql, int qr, const unsigned &qv){
		_modify(ql,qv), _modify(qr+1,-uint64_t(qv));
	}
	inline uint64_t query(int ql, int qr){
		return _query(qr)-_query(ql-1);
	}
}

uint64_t getAns(int x){
	if(!heavy[x]) return 0u; // leaf
	const uint64_t d = Tagger::query(dfn[x]);
	uint64_t my = SgTree::query(dfn[x],ed[x]); // real
	uint64_t him = SgTree::query(dfn[heavy[x]],ed[heavy[x]]);
	uint64_t alone = SgTree::query(dfn[x],dfn[x]);
	him = him*him+lig[x][1]+((lig[x][0]<<1)+lsiz[x]*d)*d;
	return my*my-alone*alone-him;
}

char opt[10];
int main(){
	int n = readint(), q = readint();
	memset(head+1,-1,n<<2), cntEdge = 0;
	for(int i=1; i!=n; ++i) addEdge(readint(),i+1);
	rep(i,1,n) v[i] = readint();
	scan(1), dfs(1,1); // basic info
	rep(i,1,n) SgTree::modify(dfn[i],dfn[i],v[i]);
	for(unsigned x,y; q; --q){
		scanf("%s",opt), x = readint();
		if(*opt == 'Q'){
			writeint(getAns(x)>>1);
			putchar('\n');
		}
		else if(*opt == 'S'){
			update_chain(x, y = readint());
			SgTree::modify(dfn[x],dfn[x],y);
		}
		else if(*opt == 'M'){
			y = readint();
			update_chain(x,uint64_t(siz[x])*y);
			SgTree::modify(dfn[x],ed[x],y);
			Tagger::modify(dfn[x],ed[x],y);
		}
	}
	return 0;
}