CF1254D Tree Queries 题解

CF1254D Tree Queries 题解

---

知识点

树剖，树状数组，线段树，DFS 序。

---

分析

首先知道，题目中的期望就是骗人的，我们先不除以 \(n\)，等把答案统计完了之后再除以一个 \(n\) 即可。

接下来考虑如何统计：

• 在更新的时候将点分种类讨论：假设现在更新操作为 1 v d。

  1. 对于点 \(v\)：

     直接加上 \(nd\)，因为所有的路径都一定经过它。

     直接在外面开一个数组记下来就好了，时间复杂度 \(O(1)\)。

  2. 对于不在 \(v\) 子树内的点：

     对于这些点，每个有可能的 \(r\) 都在 \(v\) 的子树内，所以都要加上 \(siz_vd\)。

     直接 DFN 区间加即可，时间复杂度 \(O(\log_2{n})\)。

  3. 其余在 \(v\) 子树内的点：

     对于某个点 \(u\)，设 \(v\) 离它最近的子节点为 \(x\)，那么有可能的 \(r\) 都在 \(x\) 的子树外，所以要加上 \((n-siz_x)d\)，但是我们没有办法一个个访问子节点来修改，怎么办呢？

     我们考虑只将 \(v\) 重儿子 \(son\) 内的子节点加上 \((n-siz_{son})d\)，然后在 \(v\) 上打一个标记，这个标记是等到查询的时候再按树链走上来统计。

     所以要一个 DFN 区间加，和用数组记下查询时用的标记，时间复杂度 \(O(\log_2{n})\)。

• 现在看到查询：2 v。

  那么我们需要先把区间加的部分统计出来，把数组中标记的也加上，再按树链往上走，把没加的标记加上，时间复杂度 \(O(\log_2{n})\)。

代码

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define ll long long
#define RCL(a,b,c,d) memset(a,b,sizeof(c)*(d))
#define tomin(a,...) ((a)=min({(a),__VA_ARGS__}))
#define tomax(a,...) ((a)=max({(a),__VA_ARGS__}))
#define FOR(i,a,b) for(int i(a); i<=(int)(b); ++i)
#define DOR(i,a,b) for(int i(a); i>=(int)(b); --i)
#define EDGE(g,i,x,y) for(int i(g.h[x]),y(g[i].v); ~i; y=g[i=g[i].nxt].v)
using namespace std;
constexpr int N(1.5e5+10);

struct Ecat {
#define DE(...) E(#__VA_ARGS__,__VA_ARGS__)

	template<class T>void operator ()(const char *fmt,const T x) {
		cerr<<fmt<<':'<<x<<'.'<<endl;
	}

	template<class T,class...Types>void operator ()(const char *fmt,const T x,const Types...args) {
		while(*fmt^',')cerr<<*fmt++;
		return cerr<<':'<<x<<" ,",(*this)(++fmt,args...);
	}

} E;

namespace Modular {
#define Mod 998244353
	template<class T1,class T2>constexpr auto add(const T1 a,const T2 b) {
		return a+b>=Mod?a+b-Mod:a+b;
	}

	template<class T1,class T2>constexpr auto mul(const T1 a,const T2 b) {
		return (ll)a*b%Mod;
	}

	template<class T,class...Types>constexpr auto add(const T a,const Types...args) {
		return add(a,add(args...));
	}

	template<class T,class...Types>constexpr auto mul(const T a,const Types...args) {
		return mul(a,mul(args...));
	}

	template<class T1,class T2>T1 &toadd(T1 &a,const T2 b) {
		return a=add(a,b);
	}

	template<class T1,class T2>T1 &tomul(T1 &a,const T2 b) {
		return a=mul(a,b);
	}

	template<class T0,class T,class...Types>T0 &toadd(T0 &a,const T b,const Types...args) {
		return toadd(a,b),toadd(a,args...);
	}

	template<class T0,class T,class...Types>T0 &tomul(T0 &a,const T b,const Types...args) {
		return tomul(a,b),tomul(a,args...);
	}
	
	int Pow(int a,int b=Mod-2) {
		int res(1);
		for(a%=Mod; b; b>>=1,tomul(a,a))if(b&1)tomul(res,a);
		return res;
	}

} using namespace Modular;

int n,Q,idx;
int dl[N],dr[N],fa[N],dep[N],dfn[N],siz[N],son[N],top[N],tag[N];
vector<int> g[N];
struct BIT {
#define lowbit(i) ((i)&-(i))
	int c[N];
	
	void Plus(int x,int d) {
		if(x>0)for(; x<=n; x+=lowbit(x))toadd(c[x],d);
	}
	
	void Plus(int l,int r,int d) {
		Plus(l,d),Plus(r+1,Mod-d);
	}
	
	int Sum(int x) {
		int ans(0);
		if(x>0)for(; x; x&=x-1)toadd(ans,c[x]);
		return ans;
	}
	
} bit;

void dfs0(int u) {
	dep[u]=dep[fa[u]]+1,siz[u]=1,son[u]=0;
	for(int v:g[u])if(v^fa[u])fa[v]=u,dfs0(v),siz[u]+=siz[v],son[u]=(siz[v]>siz[son[u]]?v:son[u]);
}

void dfs1(int u) {
	dfn[dl[u]=++idx]=u;
	if(son[u])top[son[u]]=top[u],dfs1(son[u]);
	for(int v:g[u])if(v!=fa[u]&&v!=son[u])dfs1(top[v]=v);
	dr[u]=idx;
}

int main() {
	cin>>n>>Q;
	FOR(i,2,n) {
		int u,v;
		cin>>u>>v,g[u].push_back(v),g[v].push_back(u);
	}
	dfs0(1),dfs1(top[1]=1);
	while(Q--) {
		int c,v,d;
		cin>>c>>v;
		if(c==1) {
			cin>>d,toadd(tag[v],d);
			if(dl[v]>1)bit.Plus(1,dl[v]-1,mul(siz[v],d));
			if(dr[v]<n)bit.Plus(dr[v]+1,n,mul(siz[v],d));
			if(son[v])bit.Plus(dl[son[v]],dr[son[v]],mul(n-siz[son[v]],d));
		} else {
			int ans(add(bit.Sum(dl[v]),mul(tag[v],n)));
			for(int u(v); fa[top[u]]; u=fa[top[u]])toadd(ans,mul(n-siz[top[u]],tag[fa[top[u]]]));
			cout<<mul(ans,Pow(n))<<'\n';
		}
	}
	return 0;
}