CF1254D Tree Queries

考虑分析一次修改的本质是什么：

• 对于一次修改 \(u,x\)，我们删去 \(u\)，会出现若干联通块。
• 对于一个大小为 \(s\) 的联通块，每个点加上 \(\dfrac{n-s}n\)。

不妨让每个点加的值从 \(\dfrac{n-s}n\) 变成 \(n-s\)，最后乘上一个 \(n^{-1}\bmod998244353\) 即可。

我们记一个点的度数为 \(d_u\)。然后考虑两种算法：

• 暴力 \(\tt1\)：修改时枚举 \(u\) 的所有儿子 \(v\)，暴力按上述式子加（子树加，使用修改复杂度 \(\mathcal O(k)\) 的数据结构维护），最后处理父亲（父亲所在联通块的大小应该是 \(n-u\) 的字数大小）
• 暴力 \(\tt2\)：查询时枚举一些点 \(v\)（当然 \(v\ne u\)），然后判断 \(u\) 在 \(v\) 的哪个联通块（要么 \(u\) 是 \(v\) 的祖先，要么找到一个 \(v\) 的儿子 \(w\)，使得 \(w\) 是 \(u\) 的祖先），然后根据所在联通块计算 \(v\) 对 \(u\) 的贡献是多少。

哦，但是还要注意如果发生过修改 \(\{u,x\}\)，那么 \(u\) 的答案最后要加上 \(x\)。

这两种算法的复杂度分别是 \(\mathcal O(kd_u)\) 和 \(\mathcal O(t)\)，其中 \(t\) 是你选择枚举的点数，\(k\) 是你选择的数据结构修改的复杂度。

这并不优。于是常规手段，根号摊平。（以下的查询指计算这个点对其它点的贡献）

• 对于 \(d_u\le\sqrt n\) 的点的修改，使用暴力 \(\tt1\) 中的修改。
• 对于 \(d_u\le\sqrt n\) 的点的查询，用数据结构算出任何 \(d_v\le\sqrt n\) 的 \(v\) 对 \(u\) 的答案。
• 对于 \(d_u\gt\sqrt n\) 的点的修改，考虑跳过，直接摆烂。
• 对于 \(d_u\gt\sqrt n\) 的点的查询，枚举这些点（总个数 \(t=\mathcal O(\dfrac n{\sqrt n})=\mathcal O(\sqrt n)\)），然后计算贡献。

数据结构我们希望做到修改 \(\mathcal O(1)\)，这样才能保证最后根号的复杂度。

根号题用根号 \(\tt DS\) 是极好的，我们选择采用序列分块，这个子树加单点和是常规的 \(\tt dfs\) 时间戳。

在补充说说。暴力 \(\tt2\) 里有一步是对于 \(u,v\) 要找到一个 \(w\)，满足 \(w\) 是 \(v\) 的儿子，也是 \(u\) 的祖先。这一步其实挺像 \(\tt LCA\)，考虑树剖解决：

我们魔改树求 \(\tt LCA\)，在最后一步，两个点都在一条重链的时候，深度小的那个点在重链上的儿子就是答案。

还有一种情况，就是它们中深度小的那个在重链底，这时答案是它的某个轻儿子，我们无法得知。这种情况需要在跳重链的时候，如果某一步出现 \(x\) 的重链顶的父亲是 \(y\)，就不跳了，返回 \(x\) 的重链顶就是答案。

const int N = 1.5e5 + 5,SQ = 405;
const ll mod = 998244353;

int n,m; ll inv_n,add[N];
vector<int> G[N],big;

int B,C,st[SQ],ed[SQ],bl[N];
ll sum[SQ],cnt[N];

int dep[N],siz[N],son[N],fa[N];
int dfn[N],top[N],tot = 0;

#define Big(i) ((signed)G[i].size() > B)
#define rdfn(u) dfn[u] + siz[u] - 1
#define subt(u) dfn[u],rdfn(u)

namespace HLC{
	void dfs1(int u = 1,int ft = 0){
		dep[u] = dep[fa[u] = ft] + (siz[u] = 1);
		for(int v : G[u]) if(v != ft){
			dfs1(v,u); siz[u] += siz[v];
			if(siz[v] > siz[son[u]]) son[u] = v;
		} if(Big(u)) big.push_back(u);
	}
	
	void dfs2(int u = 1,int tp = 1){
		dfn[u] = ++tot; top[u] = tp;
		if(son[u]) dfs2(son[u],tp);
		for(int v : G[u]) if(!top[v]) dfs2(v,v);
	}
	
	int son_lca(int x,int y){
		while(top[x] != top[y]){
			if(dep[top[x]] < dep[top[y]]) swap(x,y);
			if(fa[top[x]] == y) return top[x];
			x = fa[top[x]];
		} return son[dep[x] < dep[y] ? x : y];
	}
} using namespace HLC;

namespace DS{
	void init(){
		B = sqrt(n); C = (n - 1) / B + 1;
		rep(i,1,C){
			st[i] = ed[i - 1] + 1;
			ed[i] = i == C ? n : i * B;
			rep(j,st[i],ed[i]) bl[j] = i;
		}
	}
	
	void upd(int l,int r,ll x){
		x %= mod; ++r;
		(cnt[l] += x) %= mod;
		(cnt[r] += mod - x) %= mod;
		(sum[bl[l]] += x) %= mod;
		(sum[bl[r]] += mod - x) %= mod;
	}
	
	ll qry(int p){
		ll res = 0;
		rep(i,1,bl[p] - 1) (res += sum[i]) %= mod;
		rep(i,st[bl[p]],p) (res += cnt[i]) %= mod;
		return res;
	}
} using namespace DS;

void Upd(int u,ll x){
	(add[u] += x) %= mod; if(Big(u)) return;
	for(int v : G[u]) if(v != fa[u])
		DS::upd(subt(v),x * (n - siz[v]));
	if(u == 1) return;
	ll y = x * siz[u]; upd(subt(1),y); upd(subt(u),-y);
}

ll Qry(int u){
	ll res = qry(dfn[u]);
	for(int v : big) if(u != v){
		if(!(dfn[v] <= dfn[u] && rdfn(u) <= rdfn(v)))
			(res += add[v] * siz[v] % mod) %= mod;
		else (res += add[v] * (n - siz[son_lca(u,v)]) % mod) %= mod;
	} res = ((inv_n * res % mod) + add[u]) % mod;
	return (res % mod + mod) % mod;
}

ll fpow(ll v,int b){
	ll res = 1;
	while(b){
		if(b & 1) (res *= v) %= mod;
		(v *= v) %= mod; b >>= 1;
	}
	return res;
}

signed main(){
	read(n,m);
	inv_n = fpow(n,mod - 2);
	rep(i,1,n - 1){
		int u,v; read(u,v);
		G[u].push_back(v);
		G[v].push_back(u);
	}
	init(); dfs1(); dfs2();
	while(m--){
		if(read() == 1){ int x = read(); Upd(x,read()); }
		else print(Qry(read()),'\n');
	}
	return 0;
}