计蒜客 Red Black Tree(树形DP)

You are given a rooted tree with n nodes. The nodes are numbered 1..n. The root is node 1, and m of the nodes are colored red, the rest are black.

You would like to choose a subset of nodes such that there is no node in your subset which is an ancestor of any other node in your subset. For example, if A is the parent of B and B is the parent of C, then you could have at most one of A, B or C in your subset. In addition, you would like exactly k of your chosen nodes to be red.

If exactly mm of the nodes are red, then for all k = 0..m, figure out how many ways you can choose subsets with k red nodes, and no node is an ancestor of any other node.

Input Format

Each input will consist of a single test case.

Note that your program may be run multiple times on different inputs.

Each test case will begin with a line with two integers n(1≤n≤2×10^5) and m(0≤m≤min(10^3,n)), where n is the number of nodes in the tree, and m is the number of nodes which are red. The nodes are numbered 1..n.

Each of the next n - 1 lines will contain a single integer p(1≤p≤n), which is the number of the parent of this node. The nodes are listed in order, starting with node 2, then node 3, and so on. Node 1 is skipped, since it is the root. It is guaranteed that the nodes form a single tree, with a single root at node 1 and no cycles.

Each of the next m lines will contain single integer r(1≤r≤n). These are the numbers of the red nodes. No value of r will be repeated.

Output Format

Output m + 1 lines, corresponding to the number of subsets satisfying the given criteria with a number of red nodes equal to k = 0..m, in that order. Output this number modulo 10^9 + 7.

样例输入1

样例输出1

5

4

样例输入2

样例输出2

样例输入3

样例输出3

题意

一棵树，n个点，其中有m个红色，其余为黑点，1为根，选1个点集合，集合内的任意两点不互为祖先，问集合内红色节点的个数为0-m的方案数。

题解

dp[root][m]代表根为root的子树红色节点为m的方案数。

不选root，dp[root][0]=1，考虑子树son的情况，考虑h[M]代表组成M的方案数，相当于每次一颗子树把里面的所有红色节点一个一个压进去，类似于背包。

选root，dp[root][red[root]]++，相当于下面都不能选。

代码

 #include<bits/stdc++.h>

 using namespace std;

 const int N=;

 const int M=;

 const int MD=;

 int dp[N][M],h[M],red[N],sz[N];

 int n,m;

 vector<int>G[N];

 void dfs(int u){

     dp[u][]=;

     sz[u]=red[u];

     for(int i=;i<G[u].size();i++) {

         int v=G[u][i];

         dfs(v);

         int up=min(sz[u]+sz[v],m);

         for(int j=;j<=up;j++)h[j]=;

         for(int j=;j<=sz[v];j++)

             for(int k=;k<=sz[u]&&j+k<=up;k++)

                 h[j+k]=(h[j+k]+1LL*dp[v][j]*dp[u][k])%MD;

         sz[u]+=sz[v];

         for(int j=;j<=sz[u];j++)dp[u][j]=h[j];

     }

     dp[u][red[u]]=(dp[u][red[u]]+)%MD;

 }

 int main() {

     scanf("%d%d",&n,&m);

     for(int i=,u;i<=n;i++) {

         scanf("%d",&u);

         G[u].push_back(i);

     }

     for(int i=,x;i<m;i++) {

         scanf("%d",&x);

         red[x]=;

     }

     dfs();

     for(int i=;i<=m;i++)

         printf("%d\n",dp[][i]);

     return ;

 }