【刷题】洛谷 P3676 小清新数据结构题

题目背景

本题时限2s，内存限制256M

题目描述

在很久很久以前，有一棵n个点的树，每个点有一个点权。

现在有q次操作，每次操作是修改一个点的点权或指定一个点，询问以这个点为根时每棵子树点权和的平方和。

（题目不是很好懂，没看太懂的可以看看样例解释）

输入输出格式

输入格式：

第一行两个整数n、q。

接下来n-1行每行两个整数a和b，表示树中a与b之间有一条边，保证给出的边不会重复。

接下来一行n个整数，第i个整数表示第i个点的点权。

接下来q行每行两或三个数，如果第一个数为1，那么接下来有两个数x和y，表示将第x个点的点权修改为y，如果第一个数为2，那么接下来有一个数x，表示询问以x为根时每棵子树点权和的平方和。

输出格式：

对于每个询问输出答案。

输入输出样例

输入样例#1：

4 5

1 2

2 3

2 4

4 3 2 1

2 2

1 1 3

2 3

1 2 4

2 4

输出样例#1：

121

140

194

说明

样例解释

这是一个菊花图，2与1、3、4间有边。

一开始每个点点权分别为4、3、2、1。

第一个询问以2为根，1、3、4子树中都只有本身一个点，2子树中有所有点，那么1、3、4子树中的点权和就分别是自己的点权4、2、1，2子树中的点权和就是4+3+2+1=10， \(4^2+2^2+1^1+10^2=121\) 。

接下来将第一个点点权修改为3，每个点点权分别为3、3、2、1。

第二个询问以3为根，1、4子树中只有自己，2子树中有1、2、4，3子树中有所有点，1、4子树点权和就是自己的点权3、1，2子树点权和就是3+3+1=7，3子树点权和为3+3+2+1=9， \(3^2+1^2+7^2+9^2=140\) 。

接下来把第二个点点权修改为4，每个点点权分别为3、4、2、1。

第三个询问以4为根，1、3子树点权和就是3和2，2子树点权和就是3+4+2=9，4子树点权和为3+4+2+1=10， \(3^2+2^2+9^2+10^2=194\) 。

数据范围

对于10%的数据， \(n,q \leq 2000\) 。

对于40%的数据， \(n,q \leq 60000\) 。

对于另外30%的数据，保证每次询问的根都为1。

对于100%的数据， \(1 \leq n,q \leq 200000\) ， \(-10 \leq\) 输入的每个点权 \(\leq 10\) 。

建议使用输入优化，虽然标程没加读入优化也能过

题解

不会动态点分治，于是树剖乱搞

树剖加线段树，线段树维护一个区间和，一个区间和的平方，一个lazy标记

考虑部分分，所有询问的根均为1的怎么做

如果一个修改改的是 \(u\) 点，那么这次修改影响了的点只有 \(u\) 到 \(1\) 号点路径上的点，只有这些点的子树和和子树和的平方有变化，考虑这个变化

令 \(p=newval_u-oldval_u\)，即 \(p\) 是 \(u\) 点增加（或减少）的权值

它到根的路径上的点的子树和修改很简单，直接线段树区间add就行了，看和的平方的增加，把剖好后的每一条链对应到区间上， \(\sum (s_i+p)^2=\sum s_i^2+2s_ip+p^2=\sum s_i^2+2p\sum s_i+p^2len\) ，可以知道这一段区间所有位置的平方和的增加的贡献是一样的，因此也可以lazy。

那么如果一个区间上有lazy标记 \(p\) ，先要算新的区间和的平方（因为式子与旧的区间和有关系，如果先算区间和会导致平方的答案错误），直接加 \(2p\sum s_i+p^2len\) ，然后算新的区间和

然后询问的根为1的就做完了，答案就是整个线段树的区间和

然后看询问的根不为1的怎么做

同样，默认把根作为1，按照根为1的方法维护线段树，可以得到某棵树中，根为1的答案 \(stans\)

然后就看，怎样把根为1的答案变成根为询问的点的答案

假设询问的点为 \(u\)

同样，树的形态改变后，子树和有变化的也只有 \(u\) 到 \(1\) 的路径上的点，将这些点按深度从小到大排序，得到序列 \(p_1,p_2,p_3,...,p_{cnt}\)

易得式子， \(ans=stans-\sum_{i=1}^{cnt} a_{p_i}^2+\sum_{i=1}^{cnt}b_{p_i}^2\)，其中 \(a_i\) 表示以1为根时， \(i\) 的子树和， \(b_i\) 表示以 \(u\) 为根时， \(i\) 的子树和

然后有这样一个等式，\(b_{p_i}+a_{p_{i+1}}=a_{p_1}=b_{p_{cnt}}\) ，它们都等于整棵树的权值和的平方

然后式子化简

\(ans=stans-\sum_{i=1}^{cnt} a_{p_i}^2+b_{p_{cnt}}^2+\sum_{i=1}^{cnt-1}(a_{p_1}-a_{p_{i+1}})^2\)

\(~~~~~~~~=stans+a_{p_1}^2-\sum_{i=1}^{cnt} a_{p_i}^2+\sum_{i=1}^{cnt-1}a_{p_1}^2-2a_{p_1}a_{p_{i+1}}+a_{p_{i+1}}^2\)

\(~~~~~~~~=stans+a_{p_1}^2-\sum_{i=1}^{cnt} a_{p_i}^2+(cnt-1)a_{p_1}^2-2a_{p_1}\sum_{i=2}^{cnt}a_{p_i}+\sum_{i=2}^{cnt}a_{p_i}^2\)

\(~~~~~~~~=stans+a_{p_1}^2-a_{p_1}^2+(cnt-1)a_{p_1}^2-2a_{p_1}\sum_{i=1}^{cnt}a_{p_i}+2a_{p_1}^2\)

\(~~~~~~~~=stans+(cnt+1)a_{p_1}^2-2a_{p_1}\sum_{i=1}^{cnt}a_{p_i}\)

而 \(cnt\) 其实就是 \(u\) 的dep，\(\sum_{i=1}^{cnt}a_{p_i}\) 就是以1为根的时候 \(u\) 到 \(1\) 路径上的子树和的和，这个就在线段树里已经维护了

然后直接算新的答案就可以了，程序里维护的树的形态根本不用改变

#include<bits/stdc++.h>
#define ui unsigned int
#define ll long long
#define db double
#define ld long double
#define ull unsigned long long
const int MAXN=200000+10,inf=0x3f3f3f3f;
int n,q,e,to[MAXN<<1],nex[MAXN<<1],beg[MAXN],sum[MAXN],vl[MAXN],st[MAXN],ed[MAXN],cnt,fa[MAXN],top[MAXN],hson[MAXN],size[MAXN],val[MAXN],dep[MAXN];
ll stans;
#define Mid ((l+r)>>1)
#define ls rt<<1
#define rs rt<<1|1
#define lson ls,l,Mid
#define rson rs,Mid+1,r
struct Segment_Tree{
	ll Sum1[MAXN<<2],Sum2[MAXN<<2],Add[MAXN<<2];
	inline void PushUp(int rt)
	{
		Sum1[rt]=Sum1[ls]+Sum1[rs];
		Sum2[rt]=Sum2[ls]+Sum2[rs];
	}
	inline void PushDown(int rt,int len)
	{
		Sum2[ls]+=1ll*Add[rt]*Add[rt]*(len-(len>>1))+2ll*Add[rt]*Sum1[ls];
		Sum2[rs]+=1ll*Add[rt]*Add[rt]*(len>>1)+2ll*Add[rt]*Sum1[rs];
		Sum1[ls]+=1ll*Add[rt]*(len-(len>>1));
		Sum1[rs]+=1ll*Add[rt]*(len>>1);
		if(Add[ls]==inf)Add[ls]=0;
		if(Add[rs]==inf)Add[rs]=0;
		Add[ls]+=Add[rt];Add[rs]+=Add[rt];
		Add[rt]=inf;
	}
	inline void Build(int rt,int l,int r)
	{
		Add[rt]=inf;
		if(l==r)
		{
			Sum1[rt]=vl[l];
			Sum2[rt]=1ll*vl[l]*vl[l];
		}
		else
		{
			Build(lson);Build(rson);
			PushUp(rt);
		}
	}
	inline void Update(int rt,int l,int r,int L,int R,ll k)
	{
		if(L<=l&&r<=R)
		{
			Sum2[rt]+=1ll*k*k*(r-l+1)+2ll*k*Sum1[rt];
			Sum1[rt]+=1ll*(r-l+1)*k;
			if(Add[rt]==inf)Add[rt]=0;
			Add[rt]+=k;
		}
		else
		{
			if(Add[rt]!=inf)PushDown(rt,r-l+1);
			if(L<=Mid)Update(lson,L,R,k);
			if(R>Mid)Update(rson,L,R,k);
			PushUp(rt);
		}
	}
	inline ll Query(int rt,int l,int r,int L,int R)
	{
		if(L<=l&&r<=R)return Sum1[rt];
		else
		{
			ll res=0;
			if(Add[rt]!=inf)PushDown(rt,r-l+1);
			if(L<=Mid)res+=Query(lson,L,R);
			if(R>Mid)res+=Query(rson,L,R);
			return res;
		}
	}
};
Segment_Tree T;
#undef Mid
#undef ls
#undef rs
#undef lson
#undef rson
template<typename T> inline void read(T &x)
{
	T data=0,w=1;
	char ch=0;
	while(ch!='-'&&(ch<'0'||ch>'9'))ch=getchar();
	if(ch=='-')w=-1,ch=getchar();
	while(ch>='0'&&ch<='9')data=((T)data<<3)+((T)data<<1)+(ch^'0'),ch=getchar();
	x=data*w;
}
template<typename T> inline void write(T x,char ch='\0')
{
	if(x<0)putchar('-'),x=-x;
	if(x>9)write(x/10);
	putchar(x%10+'0');
	if(ch!='\0')putchar(ch);
}
template<typename T> inline void chkmin(T &x,T y){x=(y<x?y:x);}
template<typename T> inline void chkmax(T &x,T y){x=(y>x?y:x);}
template<typename T> inline T min(T x,T y){return x<y?x:y;}
template<typename T> inline T max(T x,T y){return x>y?x:y;}
inline void insert(int x,int y)
{
	to[++e]=y;
	nex[e]=beg[x];
	beg[x]=e;
}
inline void dfs(int x,int f)
{
	sum[x]=val[x];
	for(register int i=beg[x];i;i=nex[i])
		if(to[i]==f)continue;
		else dfs(to[i],x),sum[x]+=sum[to[i]];
}
inline void dfs1(int x,int f)
{
	int res=0;
	size[x]=1;fa[x]=f;dep[x]=dep[f]+1;
	for(register int i=beg[x];i;i=nex[i])
		if(to[i]==f)continue;
		else
		{
			dfs1(to[i],x);
			size[x]+=size[to[i]];
			if(size[to[i]]>res)res=size[to[i]],hson[x]=to[i];
		}
}
inline void dfs2(int x,int tp)
{
	st[x]=++cnt;vl[cnt]=sum[x];top[x]=tp;
	if(hson[x])dfs2(hson[x],tp);
	for(register int i=beg[x];i;i=nex[i])
		if(to[i]==fa[x]||to[i]==hson[x])continue;
		else dfs2(to[i],to[i]);
	ed[x]=cnt;
}
inline void init()
{
	dfs1(1,0);dfs2(1,1);
	T.Build(1,1,n);stans=T.Sum2[1];
}
inline void Doans(int x,ll k)
{
	while(x)
	{
		T.Update(1,1,n,st[top[x]],st[x],k);
		x=fa[top[x]];
	}
}
inline ll Getans(int x)
{
	if(x==1)return stans;
	ll a0=T.Query(1,1,n,st[1],st[1]),res=stans+1ll*(dep[x]+1)*a0*a0,nsum=0;
	while(x)
	{
		nsum+=T.Query(1,1,n,st[top[x]],st[x]);
		x=fa[top[x]];
	}
	return res-2ll*a0*nsum;
}
int main()
{
	read(n);read(q);
	for(register int i=1;i<n;++i)
	{
		int u,v;read(u);read(v);
		insert(u,v);insert(v,u);
	}
	for(register int i=1;i<=n;++i)read(val[i]);
	dfs(1,0);
	init();
	while(q--)
	{
		int opt;read(opt);
		if(opt==1)
		{
			int x,y;read(x);read(y);
			Doans(x,y-val[x]);
			val[x]=y;stans=T.Sum2[1];
		}
		if(opt==2)
		{
			int x;read(x);
			write(Getans(x),'\n');
		}
	}
	return 0;
}