题意:给定一棵树,把一些节点染黑,使任意节点到离它最近黑点的距离不超过k
思路:
这是一道个人认为比较好玩但也比较难写的题目
看到这个数据范围,其实还是挺蛋疼的,因为CF的机子你也不知道能跑多快
看了下status,AC程序的状态貌似挺多,但是大同小异
如果一个点到离它最近黑点的距离大于k,那么我们称它为未覆盖点
我写的状态是
f[i][0/1][j]
表示i的子树中,与i距离最远的未覆盖点和i的距离为j/与i距离最近的染色点和i的距离为j,0/1状态分别表示前后者
起初我想的转移是枚举每棵子树中最远的未覆盖点/最近的染色点,以此确定状态进行转移,由于这种转移要枚举所有子树,所以我改成了vector作邻接表
一开始有些zz,本来是正确的状态,但被聪爷爷往沟里带多加了一维导致转移极为繁琐
还好改了回来
比较容易进行分开讨论
0状态的转移就是子树状态为0或者状态为1,但黑点染不到最远的0点
1状态的转移就是子树状态为1或者状态为0,黑点可以染到最远的0点
特殊处理
f[x][0][0]
和
f[x][1][0]
然后就转移成了一坨
每次转移要枚举当前子树v和它的j,还要枚举其它子树和它们的j,所以时间复杂度是
O(n2k2)
#include<cstdio>
#include<iostream>
#include<vector>
#define mo 1000000007
using namespace std;
int n,m,tot;
int f[105][2][105];
vector<int> e[105];
void dfs(int x,int fa)
{
f[x][1][0]=1;
f[x][0][0]=1;
int v;
for (int i=0;i<e[x].size();++i)
if (e[x][i]!=fa)
{
v=e[x][i];
dfs(v,x);
//f[x][0][j]表示x子树有不在掌控范围内的点,离x最远距离为j
//f[x][1][j]表示x子树都被掌控了,离x最近的黑色距离为j
//父亲影响子树,子树影响父亲,子树影响子树
f[x][0][0]=1LL*f[x][0][0]*f[v][1][m]%mo;
int t=0;//如果x染成黑色
for (int j=0;j<=m;++j) t=(t+f[v][1][j])%mo;
for (int j=0;j<m;++j) t=(t+f[v][0][j])%mo;
f[x][1][0]=1LL*f[x][1][0]*t%mo;
}
for (int i=0;i<e[x].size();++i)
if (e[x][i]!=fa)
{
for (int j=0;j<m-1;++j)
{
v=e[x][i];
int t=f[v][0][j];
for (int k=0;k<i;++k)
if (e[x][k]!=fa)
{
int p=0;
for (int l=0;l<=j;++l) p=(p+f[e[x][k]][0][l])%mo;
for (int l=m-j-1;l<=m;++l) p=(p+f[e[x][k]][1][l])%mo;
t=1LL*t*p%mo;
}
for (int k=i+1;k<e[x].size();++k)
if (e[x][k]!=fa)
{
int p=0;
for (int l=0;l<j;++l) p=(p+f[e[x][k]][0][l])%mo;
for (int l=m-j-1;l<=m;++l) p=(p+f[e[x][k]][1][l])%mo;
t=1LL*t*p%mo;
}
(f[x][0][j+1]+=t)%=mo;
}
for (int j=0;j<m;++j)
{
v=e[x][i];
int t=f[v][1][j];
for (int k=0;k<i;++k)
if (e[x][k]!=fa)
{
int p=0;
for (int l=0;l<m-j-1;++l) p=(p+f[e[x][k]][0][l])%mo;
for (int l=j;l<=m;++l) p=(p+f[e[x][k]][1][l])%mo;
t=1LL*t*p%mo;
}
for (int k=i+1;k<e[x].size();++k)
if (e[x][k]!=fa)
{
int p=0;
for (int l=0;l<m-j-1;++l) p=(p+f[e[x][k]][0][l])%mo;
for (int l=j+1;l<=m;++l) p=(p+f[e[x][k]][1][l])%mo;
t=1LL*t*p%mo;
}
(f[x][1][j+1]+=t)%=mo;
}
}
}
main()
{
scanf("%d%d",&n,&m);
for (int x,y,i=1;i<n;++i)
scanf("%d%d",&x,&y),
e[x].push_back(y),
e[y].push_back(x);
dfs(1,0);
int ans=0;
for (int i=0;i<=m;++i) ans=(ans+f[1][1][i])%mo;
printf("%d\n",ans);
}
显然上面的转移比较繁琐,循环嵌套较多,还要考虑特判
考虑优化
能不能不枚举其它子树呢?
答案当然是可以的
状态还是一样
假设当前节点为x,枚举到子节点v
分成6种情况考虑
x状态为1,v状态为1(直接比较谁的黑点更近即可)
x状态为1,v状态为0,但是x中的黑点可以影响到v中的未覆盖点
x状态为1,v状态为0,但是x中的黑点不能影响到v中的未覆盖点
x状态为0,v状态为0(直接比较谁的未覆盖点更近即可)
x状态为0,v状态为1,但是v中的黑点可以影响到x中的未覆盖点
x状态为0,v状态为1,但是v中的黑点不能影响到x中的未覆盖点
这样一来就要比上面的程序清晰多了,而且时间复杂度也比较优秀:
O(nk2)
注意范围和边界情况
#include<cstdio>
#include<iostream>
#include<vector>
#define mo 1000000007
using namespace std;
int n,m,tot;
int f[105][2][105],g[105][2][105];
vector<int> e[105];
void dfs(int x,int fa)
{
f[x][1][0]=1;
f[x][0][0]=1;
int v;
for (int i=0;i<e[x].size();++i)
if (e[x][i]!=fa)
{
v=e[x][i];
dfs(v,x);
for (int j=0;j<=m;++j) g[x][0][j]=0,g[x][1][j]=0;
for (int j=0;j<=m;++j)
{
for (int k=0;k<=m;++k)
g[x][1][min(j,k+1)]=(g[x][1][min(j,k+1)]+1LL*f[v][1][k]*f[x][1][j]%mo)%mo;
for (int k=0;k<m-j;++k)
g[x][1][j]=(g[x][1][j]+1LL*f[v][0][k]*f[x][1][j]%mo)%mo;
for (int k=m-j;k<=m;++k)
g[x][0][k+1]=(g[x][0][k+1]+1LL*f[v][0][k]*f[x][1][j]%mo)%mo;
}
for (int j=0;j<m;++j)
{
for (int k=0;k<m-1;++k)
g[x][0][max(j,k+1)]=(g[x][0][max(j,k+1)]+1LL*f[v][0][k]*f[x][0][j]%mo)%mo;
for (int k=0;k<m-j;++k)
g[x][1][k+1]=(g[x][1][k+1]+1LL*f[v][1][k]*f[x][0][j]%mo)%mo;
for (int k=m-j;k<=m;++k)
g[x][0][j]=(g[x][0][j]+1LL*f[v][1][k]*f[x][0][j]%mo)%mo;
}
for (int j=0;j<m;++j) f[x][0][j]=g[x][0][j];
for (int j=0;j<=m;++j) f[x][1][j]=g[x][1][j];
}
}
main()
{
scanf("%d%d",&n,&m);
for (int x,y,i=1;i<n;++i)
scanf("%d%d",&x,&y),
e[x].push_back(y),
e[y].push_back(x);
dfs(1,0);
int ans=0;
for (int i=0;i<=m;++i) ans=(ans+f[1][1][i])%mo;
printf("%d\n",ans);
}