[JSOI 2018] 潜入行动

[题目链接]

https://www.lydsy.com/JudgeOnline/problem.php?id=5314

[算法]

考虑dp ， 用f[i][j][0 / 1][0 / 1]表示以i为根的子树中选了j个 ， 是否选i ， i是否被覆盖的方案数

树形背包进行合并 ， 转移即可

时间复杂度 : O(NK)

[代码]

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
const int MAXN = 1e5 + ;
const int MAXK = ;
const int P = 1e9 + ;

struct edge
{
        int to , nxt;
} e[MAXN << ];

int n , K , tot;
int head[MAXN] , dp[MAXN][MAXK][][] , tmp[MAXK][][] , size[MAXN];

#define rint register int

template <typename T> inline void chkmax(T &x,T y) { x = max(x,y); }
template <typename T> inline void chkmin(T &x,T y) { x = min(x,y); }
template <typename T> inline void read(T &x)
{
    T f = ; x = ;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
    for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';
    x *= f;
}
inline void addedge(int x , int y)
{
        ++tot;
        e[tot] = (edge){y , head[x]};
        head[x] = tot;
}
inline void update(int &x , int y)
{
        x += y;
        while (x >= P) x -= P;
}
inline void dfs(int u , int par)
{
        size[u] = ;
        dp[u][][][] = ;
        dp[u][][][] = ;
        for (rint i = head[u]; i; i = e[i].nxt)
        {
                int v = e[i].to;
                if (v == par) continue;
                dfs(v , u);
                for (rint j = min(K , size[u] + size[v]); j >= ; --j)
                {
                        tmp[j][][] = ;
                        tmp[j][][] = ;
                        tmp[j][][] = ;
                        tmp[j][][] = ;
                }
                for (rint j = ; j <= size[u] && j <= K; ++j)
                {
                        for (rint k = ; k <= size[v] && j + k <= K; ++k)
                        {
                                if (dp[u][j][][])
                                {
                                        update(tmp[j + k][][] , 1LL * dp[u][j][][] * dp[v][k][][] % P);
                                        update(tmp[j + k][][] , 1LL * dp[u][j][][] * dp[v][k][][] % P);
                                        update(tmp[j + k][][] , 1LL * dp[u][j][][] * dp[v][k][][] % P);
                                        update(tmp[j + k][][] , 1LL * dp[u][j][][] * dp[v][k][][] % P);
                                }
                                if (dp[u][j][][])
                                {
                                        update(tmp[j + k][][] , 1LL * dp[u][j][][] * dp[v][k][][] % P);
                                        update(tmp[j + k][][] , 1LL * dp[u][j][][] * dp[v][k][][] % P);
                                        update(tmp[j + k][][] , 1LL * dp[u][j][][] * dp[v][k][][] % P);
                                        update(tmp[j + k][][] , 1LL * dp[u][j][][] * dp[v][k][][] % P);
                                }
                                if (dp[u][j][][])
                                {
                                        update(tmp[j + k][][] , 1LL * dp[u][j][][] * dp[v][k][][] % P);
                                        update(tmp[j + k][][] , 1LL * dp[u][j][][] * dp[v][k][][] % P);
                                }
                                if (dp[u][j][][])
                                {
                                        update(tmp[j + k][][] , 1LL * dp[u][j][][] * dp[v][k][][] % P);
                                        update(tmp[j + k][][] , 1LL * dp[u][j][][] * dp[v][k][][] % P);
                                }
                        }
                }
                size[u] += size[v];
                for (int j = min(K , size[u]); j >= ; --j)
                {
                        dp[u][j][][] = tmp[j][][];
                        dp[u][j][][] = tmp[j][][];
                        dp[u][j][][] = tmp[j][][];
                        dp[u][j][][] = tmp[j][][];
                }
        }
}

int main()
{

        read(n); read(K);
        for (rint i = ; i < n; ++i)
        {
                int x , y;
                read(x); read(y);
                addedge(x , y);
                addedge(y , x);
        }
        dfs( , );
        printf("%d\n" , (dp[][K][][] + dp[][K][][]) % P);

        return ;

}