【CF 736C】Ostap and Tree,树形DP

传送门

题意:给定一棵树,把一些节点染黑,使任意节点到离它最近黑点的距离不超过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(n^2k^2)$

#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(nk^2)$
注意范围和边界情况

#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);
}