潜入行动

很容易想出一个状态，设\(f[i][j][0/1]\)表示以\(i\)为根节点，安装\(j\)个监听器，根节点是否安装了监听器的总方案数

然后你去推，就会发现我们还需要知道根节点是否被监听这一个信息（最开始\(0/1\)那一维设成根节点是否被监听也是会发现需要知道根节点是否安装了监听器）

所以我们设成\(f[i][j][0/1][0/1]\)表示以\(i\)为根节点，安装\(j\)个监听器，根节点是否安装监听器，根节点是否被监听到的总方案数

写下状态转移方程，有点复杂，与题解对照一下

update 2024.6.30

像这种一个点的状况可以影响儿子和父亲的，一般有两种设法，第一种就是像上面说的这样不考虑父亲和儿子，只考虑自己是否被影响到（无论是父亲影响的还是儿子影响的）

第二种就是像“警卫安排”一样，把父亲或者儿子的状态可考虑进来

设\(g[i][j][0/1][0/1]\)表示以\(i\)为根的子树，放置\(j\)个监听器，\(i\)是否放置监听器，\(i\)的父亲是否放置监听器，使得这棵子树所有的点都被监视的总方案数

具体见如下代码（temp数组是用来减掉所有儿子都不放监听器的情况的），有推导方程，也有很多细节

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=1e5+10,K=110;
const ll p=1e9+7;
int n,k;
int End[N<<1],Next[N<<1],Last[N];
int son[N];
int f[K][2][2],g[N][K][2][2],temp[N][K];
int read()
{
    int x=0,f=1;char s=getchar();
    while(s<'0'||s>'9'){if(s=='-')f=-f;s=getchar();}
    while(s>='0'&&s<='9'){x=x*10+s-48;s=getchar();}
    return x*f;
}
int cnt;
void add(int x,int y)
{
	End[++cnt]=y,Next[cnt]=Last[x],Last[x]=cnt;
}
void dfs(int x,int fa)
{
	son[x]=1;
	g[x][0][0][1]=g[x][1][1][1]=temp[x][0]=1;//初始化，只考虑x这一个孤立结点 
	for(int i=Last[x];i;i=Next[i])
	{
		int u=End[i];
		if(u==fa) continue;
		dfs(u,x);
		for(int j=0;j<=min(k,son[x]+son[u]);j++)
		for(int l=0;l<=1;l++)
		for(int p=0;p<=1;p++)
		f[j][l][p]=0;//f是要用来记录累加和的 
		for(int j=min(son[x]+son[u],k);j>=0;j--)
		{
			for(int K=max(0,j-son[x]);K<=min(son[u],j);K++)
			//注意这里的K的起点一定要这么优化，不然会被卡常 
			{
				f[j][0][1]=((ll)f[j][0][1]+(ll)g[x][j-K][0][1]*(g[u][K][0][0]+g[u][K][1][0])%p)%p;
				f[j][1][1]=((ll)f[j][1][1]+(ll)g[x][j-K][1][1]*(g[u][K][0][1]+g[u][K][1][1])%p)%p;
			}
		}
		son[x]+=son[u];
		for(int j=0;j<=min(k,son[x]);j++)
		for(int l=0;l<=1;l++)
		g[x][j][l][1]=f[j][l][1];
	}
	//之所以要像这么拆开求，是因为要节省空间，否则的话temp数组就要多开一维变成temp[N][K][2]，就会MLE了 
	//MLE的代码可以看hydroOJ的提交 
	son[x]=1;
	for(int i=Last[x];i;i=Next[i])
	{
		int u=End[i];
		if(u==fa) continue;
		for(int j=min(son[x]+son[u],k);j>=0;j--)
		{
			ll t=0;//t是用来记录累加和的 
			for(int K=max(0,j-son[x]);K<=min(son[u],j);K++) 
			t=(t+(ll)temp[x][j-K]*g[u][K][0][0]%p)%p;
			temp[x][j]=t;
		}
		son[x]+=son[u];
		for(int j=0;j<=min(k,son[x]);j++)
		for(int l=0;l<=0;l++)
		g[x][j][l][0]=((ll)f[j][l][1]-temp[x][j]+p)%p;//容斥原理 
	}
	for(int i=0;i<=k;i++) temp[x][i]=0;
	temp[x][1]=1;
	son[x]=1;
	for(int i=Last[x];i;i=Next[i])
	{
		int u=End[i];
		if(u==fa) continue;
		for(int j=min(son[x]+son[u],k);j>=0;j--)
		{
			ll t=0;
			for(int K=max(0,j-son[x]);K<=min(son[u],j);K++) 
			t=(t+(ll)temp[x][j-K]*g[u][K][0][1]%p)%p;
			temp[x][j]=t;
		}
		son[x]+=son[u];
		for(int j=0;j<=min(k,son[x]);j++)
		for(int l=1;l<=1;l++)
		g[x][j][l][0]=((ll)f[j][l][1]-temp[x][j]+p)%p;
	}
}
int main()
{
	n=read(),k=read();
	for(int i=1,u,v;i<n;i++)
	{
		u=read(),v=read();
		add(u,v),add(v,u);
	}
	dfs(1,0);
	printf("%lld",(g[1][k][0][0]+g[1][k][1][0])%p);//最终输出答案根节点一定只能被儿子监视不能被父亲监视，因为没有父亲 
	return 0;
}