2019.12.11 B（矩阵树定理+拉格朗日插值）

问题 B: B

时限: 1 Sec  内存: 256 MB

题目描述

有一棵由n个点n-1条边构成的树，点的标号从0到n-1； 
这棵树有一个神奇的功能，我们可以将它的一条边拆掉，再将一条边连上，当然，要保证这样操作之后它还是一棵树； 
现在我们想知道，在进行不超过k次的操作后，能够造出多少种不同的树。 
定义两棵树不同为：存在一棵树中有边（x，y）而另一棵树中没有； 

输入格式

第一行两个整数n，k，意义如题中所述： 
第二行n-1个整数fi，描述了树的初始形态，第i个结点的父亲是fi； 

输出格式

一行一个整数，为可以得到的不同的树的个数，取模998244353输出；

输入样例

输入样例1：
3 1
0 0
输入样例2：
4 1
0 1 2

输出样例

输出样例1：
3
输出样例2：
8

提示

 

 

 

 

 

题解

٩(๑>◡<๑)۶人生第一道拉格朗日插值٩(๑>◡<๑)۶

终于A了。。。。。。

很套路的一道题（记得在ZROI讲过，当时并不会写插值）

就是k白边生成树计数裸题，把白边（即本题中不存在的边）边权设为x，其他边设为1，这样利用矩阵树定理求出来的就是一个多项式，x^i的系数就是选了i条白边的生成树方案数（矩阵树定理的基本性质）

由于带多项式的矩阵消元过于难写，于是我们可以考虑插值。

把x分别取0~n-1（因为求出来的多项式次数界是n，所以代n个值即可），代入基尔霍夫矩阵，然后高斯消元求行列式

把求出来的行列式的值拿来做拉格朗日插值，就可以得出答案所需的多项式

 

 

遇到这种从来没有写过（难写）的题，一定要勇于尝试，按照自己的思路来写代码，不要因其他代码而局限思维

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define N 55
const int mod=998244353;
int a[N][N],f[N],g[N],b[N],fa[N];
bool e[N][N];

int ksm(int x,int y)
{
	int ret=1;
	while(y){
		if(y&1) ret=1ll*ret*x%mod;
		y>>=1;x=1ll*x*x%mod;
	}
	return ret;
}
int gcd(int x,int y){return !y?x:gcd(y,x%y);}
int det(int n)
{
	int i,j,k,ret=1;
	int tmp;
	for(i=1;i<n;i++){
		if(!a[i][i]){
			for(j=i+1;j<=n;j++)
				if(a[j][i])break;
			if(j>n) return 0;
			for(k=1;k<=n;k++)
				swap(a[i][k],a[j][k]);
			ret=-ret;
		}
		for(j=i+1;j<=n;j++){
			if(a[j][i]){
				tmp=1ll*a[j][i]*ksm(a[i][i],mod-2)%mod;
				for(k=i;k<=n;k++)
					a[j][k]=((1ll*a[j][k]-1ll*tmp*a[i][k])%mod+mod)%mod;
			}
		}
	}
	for(i=1;i<=n;i++)
		ret=1ll*ret*a[i][i]%mod;
	return ret;
}

int main()
{
	//freopen("b.in","r",stdin);
	//freopen("b.out","w",stdout);
	
	int n,m,i,j,k;
	scanf("%d%d",&n,&m);
	for(i=2;i<=n;i++){
		scanf("%d",&fa[i]);
		fa[i]++;e[fa[i]][i]=e[i][fa[i]]=1;
	}
	for(i=0;i<n;i++){
		memset(a,0,sizeof(a));
		for(j=1;j<=n;j++){
			for(k=j+1;k<=n;k++){
				if(e[j][k]){
					a[j][k]=a[k][j]=mod-1;
					a[j][j]++;a[k][k]++;
				}
				else{
					a[j][k]=a[k][j]=mod-i;
					a[j][j]+=i;a[k][k]+=i;
				}
			}
		}
		/*for(j=1;j<=n;j++){
			for(k=1;k<=n;k++)
				printf("%d ",a[j][k]);
			printf("\n");
		}*/
		b[i]=det(n-1);
		//printf("%d\n",b[i]);
	}
	
	//n=3;b[1]=3;b[2]=7;b[3]=13;m=n;
	
	for(i=0;i<n;i++){
		memset(g,0,sizeof(g));g[n-1]=1;
		int tmp=b[i];
		for(j=0;j<n;j++)if(i!=j)
			tmp=1ll*tmp*ksm((i-j+mod)%mod,mod-2)%mod;
		for(j=0;j<n;j++)if(i!=j)
			for(k=n-j-1;k<n;k++)
				g[k]=((1ll*g[k]-1ll*j*g[k+1])%mod+1ll*mod)%mod;
		for(j=0;j<n;j++)
			f[j]=(1ll*f[j]+1ll*g[j]*tmp)%mod;
	}
	
	int ans=0;
	for(i=0;i<=min(n-1,m);i++){
		ans+=f[i];//printf("%d ",f[i]);
		if(ans>=mod)ans-=mod;
	}
	
	//printf("\n");
	
	printf("%d",ans);
}

 

 

 

还有一种方法就是矩阵树定理+容斥（stO Freopen Orz原创）（我不是很懂）

代码：

#include<bits/stdc++.h>
#define maxn 55
#define pb push_back
#define mod 998244353
using namespace std;
 
int n,K,f[maxn][maxn][maxn],sz[maxn],g[maxn][maxn],fac[maxn]={1,1},inv[maxn]={1,1},invf[maxn]={1,1},ans[maxn];
vector<int>G[maxn];
int Pow(int base,int k){
    int ret = 1;
    for(;k;k>>=1,base=1ll*base*base%mod) if(k&1) ret=1ll*ret*base%mod;
    return ret;
}
int C(int a,int b){
    return 1ll * fac[a] * invf[b] % mod * invf[a-b] % mod;
}
 
void dfs(int u){
    f[u][0][1]=1,sz[u] = 1;
    for(int i=0,v;i<G[u].size();i++){
        dfs(v=G[u][i]);
        memset(g,0,sizeof g);
        for(int a=0;a<=min(sz[u],K);a++)
            for(int b=0;b<=min(sz[v],K-a);b++)
                for(int j=0;j<=sz[u];j++)
                    for(int k=0;k<=sz[v];k++)
                        g[a+b][j+k] = (g[a+b][j+k] + 1ll * f[u][a][j] * f[v][b][k]) % mod;
        for(int k=0;k<=sz[u]+sz[v];k++)
            for(int j=0;j<=sz[u]+sz[v];j++) 
                f[u][j][k] = g[j][k];
        sz[u]+=sz[v];
    }
    for(int a=0;a<K;a++) for(int i=1;i<=sz[u];i++) f[u][a+1][0]=(f[u][a+1][0]+1ll*i*f[u][a][i])%mod;
}
 
int main(){
    scanf("%d%d",&n,&K);K=min(K,n-1),K++;
    for(int i=1,x;i<n;i++) scanf("%d",&x),G[x].pb(i);
    dfs(0);
    for(int i=2;i<=n;i++)
        fac[i] = 1ll * fac[i-1] * i % mod,
        inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod,
        invf[i] = 1ll * invf[i-1] * inv[i] % mod;
    ans[1]=1;
    for(int i=2;i<=K;i++) ans[i]=1ll*Pow(n,i-2)*f[0][i][0]%mod;
    for(int i=1;i<=K;i++)
        for(int j=i+1;j<=K;j++)
            ans[j]=(ans[j]-1ll*ans[i]*C(n-i,j-i))%mod;
    for(int i=1;i<=K;i++) ans[0]=(ans[0]+ans[i])%mod;
    printf("%d\n",(ans[0]+mod)%mod);    
}