CF2182G 题解

注意到题目给定的访问顺序就是 DFS 序。

题目其实就是在求相邻两个点距离不超过 \(k\) 的 DFS 序个数。

考虑一个点 \(u\),怎么计算以 \(u\) 为根的子树内的答案。

考虑哪些访问顺序是合法的?

首先,对于任意一个不是最后一个被访问的子树,由于接下来需要访问另一个子树的根部,故其内部最后一个被访问的点必然是某个叶子,且这个叶子的深度最多不能超过 \(dep_u+k-1\)。

令 \(f_u\) 表示 \(u\) 为根的子树答案。

令 \(g_v\) 表示 \(u\) 的儿子 \(v\) 内部的合法顺序数量(要求最后一个点的深度不超过 \(dep_u+k-1\))。

令 \(S\) 表示 \(u\) 的儿子集合。

那么钦定一个点 \(x\) 作为最后被访问的儿子,\(f_u =(|S|-1)! \sum\limits_{x}f_x\prod\limits_{v\neq x}g_v\)。

那么接下来怎么计算 \(g_v\)?

考虑对于每个 \(u\) 的儿子 \(v\),维护一个基于深度的动态开点线段树,分别维护 \(dep=1,2,\cdots,n\) 的叶子作为 \(v\) 子树最后一个被访问的点的方案数总和。

注意到完成 \(u\) 子树答案的计算之后,需要把 \(u\) 对应的这个线段树也算出来(分别维护 \(dep=1,2,\cdots,n\) 的叶子作为 \(u\) 子树最后一个被访问的点的方案数总和)。

要算出 \(u\) 对应的这个线段树,则首先对于每个深度 \(d\),其每个对应的线段树上单点值,其含义从『\(v\) 子树内最后一个被访问的点的深度为 \(d\) 的总方案数』变化为『\(u\) 最后一个被访问的儿子是 \(v\),且 \(v\) 子树内最后一个被访问的点的深度为 \(d\) 的总方案数』,含义变化之后,令 \(M=(|S|-1)!\prod\limits_{v'\neq v}g_{v'}\),其值需要乘上 \(M\),只需要对 \(v\) 的线段树全局乘 \(M\) 即可。

随后将 \(u\) 的所有的儿子的线段树合并得到 \(u\) 的线段树;另外如果 \(u\) 没有儿子的话,那么 \(u\) 自己则作为叶子,然后建立自己的线段树。此时 \(u\) 的线段树的每个单点值的含义才变为『\(u\) 子树内最后一个被访问的点的深度为 \(d\) 的总方案数』。

最终答案是 \(f_1\)。

考虑如何分析时间复杂度。

由于每次合并遇到两个非空节点,都会让这两个点其中的一个永久退出不再使用,而且只有这种情况才会产生一次 \(O(1)\) 处理。由于线段树总节点数 \(O(n\log n)\),故时间复杂度也是 \(O(n\log n)\) 的。

点击查看代码
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(auto i=(a);i<=(b);i++)
#define REP(i,a,b) for(auto i=(a);i>=(b);i--)
#define FORK(i,a,b,k) for(auto i=(a);i<=(b);i+=(k))
#define REPK(i,a,b,k) for(auto i=(a);i>=(b);i-=(k))
#define pb push_back
#define mkpr make_pair
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
template<class T>
void ckmx(T& a,T b){
    a=max(a,b);
}
template<class T>
void ckmn(T& a,T b){
    a=min(a,b);
}
template<class T>
T gcd(T a,T b){
    return !b?a:gcd(b,a%b);
}
template<class T>
T lcm(T a,T b){
    return a/gcd(a,b)*b;
}
#define gc getchar()
#define eb emplace_back
#define pc putchar
#define ep empty()
#define fi first
#define se second
#define pln pc('\n');
#define islower(ch) (ch>='a'&&ch<='z')
#define isupper(ch) (ch>='A'&&ch<='Z')
#define isalpha(ch) (islower(ch)||isupper(ch))
template<class T>
void wrint(T x){
    if(x<0){
        x=-x;
        pc('-');
    }
    if(x>=10){
        wrint(x/10);
    }
    pc(x%10^48);
}
template<class T>
void wrintln(T x){
    wrint(x);
    pln
}
template<class T>
void read(T& x){
    x=0;
    int f=1;
    char ch=gc;
    while(!isdigit(ch)){
        if(ch=='-')f=-1;
        ch=gc;
    }
    while(isdigit(ch)){
        x=(x<<1)+(x<<3)+(ch^48);
        ch=gc;
    }
    x*=f;
}
void ioopti(){
    ios::sync_with_stdio(0);
    cin.tie(0);
}
const ll mod=998244353;
const int maxn=3e5+5;
int n,k;
vi g[maxn]; 
struct NODE{
	int l,r;
	ll sum,lazymul;
	int ls,rs;
}nd[maxn*40];
int ndcnt;
int newnode(int l,int r){
	// 建立一个代表区间 [l,r] 的点 
	int pos=++ndcnt;
	nd[pos].l=l,nd[pos].r=r,nd[pos].sum=0,nd[pos].lazymul=1;
	return pos;
}
void upd(int& pos,int l,int r,ll _v){
	if(!pos){
		return;
	}
	(nd[pos].sum*=_v)%=mod;
	(nd[pos].lazymul*=_v)%=mod;
}
void pushdown(int pos,int l,int r){
	int mid=(l+r>>1);
	upd(nd[pos].ls,l,mid,nd[pos].lazymul);
	upd(nd[pos].rs,mid+1,r,nd[pos].lazymul);
	nd[pos].lazymul=1;
}
void pushup(int pos){
	nd[pos].sum=nd[nd[pos].ls].sum+nd[nd[pos].rs].sum;
	nd[pos].sum%=mod;
}
void chg(int& pos,int curl,int curr,int x,ll _v){
	if(!pos)pos=newnode(curl,curr);
	if(curl==curr){
		nd[pos].sum=_v;
		return;
	}
	pushdown(pos,curl,curr);
	int mid=(curl+curr>>1);
	if(mid>=x)chg(nd[pos].ls,curl,mid,x,_v);
	else chg(nd[pos].rs,mid+1,curr,x,_v);
	pushup(pos);
}
void mul(int& pos,int curl,int curr,int l,int r,ll _v){
	if(!pos)pos=newnode(curl,curr);
	if(curl>=l&&curr<=r){
		upd(pos,curl,curr,_v);
		return;
	}
	pushdown(pos,curl,curr);
	int mid=(curl+curr>>1);
	if(mid>=l)mul(nd[pos].ls,curl,mid,l,r,_v);
	if(mid<r)mul(nd[pos].rs,mid+1,curr,l,r,_v);
	pushup(pos);
}
ll qsum(int pos,int curl,int curr,int l,int r){
	if(!pos)return 0;
	if(curl>=l&&curr<=r){
		return nd[pos].sum;
	}
	pushdown(pos,curl,curr);
	int mid=(curl+curr>>1);
	ll res=0;
	if(mid>=l)res=qsum(nd[pos].ls,curl,mid,l,r);
	if(mid<r)(res+=qsum(nd[pos].rs,mid+1,curr,l,r))%=mod;
	return res;
}
int merge(int a,int b,int l,int r){
	if(!a)return b;
	if(!b)return a; 
	(nd[a].sum+=nd[b].sum)%=mod;
	if(l==r)return a;
	pushdown(a,l,r);
	pushdown(b,l,r);
	int mid=(l+r>>1);
	nd[a].ls=merge(nd[a].ls,nd[b].ls,l,mid);
	nd[a].rs=merge(nd[a].rs,nd[b].rs,mid+1,r);
	return a;
}
int dep[maxn];
int rt[maxn];// u 子树对应的线段树的根节点 
ll pre[maxn],suf[maxn];
ll tmp[maxn]={1};
void dfs(int u,int _fa){
	dep[u]=dep[_fa]+1;
	vi sons;
	for(int& v:g[u]){
		if(v==_fa)continue;
		dfs(v,u);
		sons.eb(v);
	}
	if(sons.empty()){
		rt[u]=newnode(1,n);
		chg(rt[u],1,n,dep[u],1);
		return;
	} 
	rt[u]=newnode(1,n);
	{
		{
			for(int v:sons){
				tmp[v]=qsum(rt[v],1,n,1,dep[u]+k-1);
			}
		}
		int prv=0;
		pre[prv]=1;
		for(int v:sons){
			pre[v]=pre[prv]*tmp[prv]%mod;
			prv=v;
		}
		prv=0;
		suf[prv]=1;
		REP(i,int(sons.size())-1,0){
			suf[sons[i]]=suf[prv]*tmp[prv]%mod;
			prv=sons[i];
		}
	}
	ll factm=1;
	FOR(i,1,sons.size()-1)(factm*=i)%=mod;
	{
		for(int v:sons){
			upd(rt[v],1,n,pre[v]*suf[v]%mod*factm%mod);
		}
	}
	for(int v:sons){
		rt[u]=merge(rt[u],rt[v],1,n);
	}
}
void clear(){
	FOR(i,1,n){
		g[i].clear();
		rt[i]=0;
	}
	// 总点数 <=3e5,我认为不需要重置 ndcnt。还能省下若干个清空操作 
}
void solve(int id_of_test){
	read(n);
	read(k);
	FOR(i,2,n){
		int p;
		read(p);
		g[i].eb(p);
		g[p].eb(i);
	}
	dfs(1,0);
	ll ans=nd[rt[1]].sum;
	printf("%lld\n",(ans%mod+mod)%mod);  
	// clear
	clear();
}
int main()
{
	int T;
	read(T);
	FOR(_,1,T){
		solve(_);
	}
	return 0;
}
/*
1. 对题意的理解能否和样例对的上?
2. 每一步操作,能否和自己的想法对应上?
3. 每一步操作的正确性是否有保证?
4. 是否考虑到了所有的 case?特别是极限数据。
5. 变量的数据类型是否与其值域匹配?
6. 时间复杂度有保证吗?
7. 空间多少 MB?
*/

posted @ 2026-11-18 09:00  vectorlmn  阅读(5)  评论(0)    收藏  举报