【CodeForces - 461B】Appleman and Tree

@Appleman and Tree@

---

@题目描述@-English

Appleman has a tree with n vertices. Some of the vertices (at least one) are colored black and other vertices are colored white.
Consider a set consisting of k (0 ≤ k < n) edges of Appleman’s tree. If Appleman deletes these edges from the tree, then it will split into (k + 1) parts. Note, that each part will be a tree with colored vertices.
Now Appleman wonders, what is the number of sets splitting the tree in such a way that each resulting part will have exactly one black vertex? Find this number modulo 1000000007 (10^9 + 7).

Input
The first line contains an integer n (2  ≤ n ≤ 10^5) — the number of tree vertices.
The second line contains the description of the tree: n - 1 integers p0, p1, …, pn - 2 (0 ≤ pi ≤ i). Where pi means that there is an edge connecting vertex (i + 1) of the tree and vertex pi. Consider tree vertices are numbered from 0 to n - 1.
The third line contains the description of the colors of the vertices: n integers x0, x1, …, xn - 1 (xi is either 0 or 1). If xi is equal to 1, vertex i is colored black. Otherwise, vertex i is colored white.

Output
Output a single integer — the number of ways to split the tree modulo 1000000007 (10^9 + 7).

Some Example

Input
3
0 0
0 1 1
Output
2

Input
6
0 1 1 0 4
1 1 0 0 1 0
Output
1

Input
10
0 1 2 1 4 4 4 0 8
0 0 0 1 0 1 1 0 0 1
Output
27

@大致题意@

Appleman 有一个含有n（2  ≤ n ≤ 10^5）个顶点的树，其中有一些是黑色的。Appleman闲来无事，想要砍掉几条边，使得剩下的连通块块儿各含有一个黑点（显然砍掉的边应该是黑色节点数 - 1）。顶点编号为0~n-1。
现输入n；输入n-1个数，第i个数Pi表顶点i与Pi连通；再输入n个数，依次表示各个顶点的颜色，0白1黑。
让你求满足Appleman要求的方案数模10^9 + 7。

---

@分析@

裸的树形dp计数。

@dp-状态定义@

现在来想想怎么定义状态吧。如图所示一棵有根树，想象将它分成几个连通块后，最特殊的是哪一块呢？显然是包含根节点的那个连通块！包含根节点那个连通块内的黑点，来源有三处：它的子树，它本身，它的父亲以上【如果它有父亲】。如果是它的父亲以上，可以交给它的父亲递归处理。如果是它本身，那它的子树要么不连通自力更生，要么连通洗白自我。如果在它的子树上，则某棵子树要养活父节点。
则我们定义二维状态：$dp[i][2]$

$$dp[i][0]：以i为根的子树割完边后，含i的连通块不含黑点的方案总数$$
$$dp[i][1]：以i为根的子树割完边后，含i的连通块含一个黑点的方案总数$$
下一步：状态转移方程式。

@dp-状态转移方程式@

考虑到根的颜色可能会对状态转移产生影响（显然的，因为如果根都是黑的怎么会有全白的状态！！！），我们进行分类讨论：
1）根为黑点时：显然$dp[i][0] = 0$。考虑状态$dp[i][1]$，对于每颗子树$j$，如果不连通，子树要自力更生即通过状态$dp[j][1]$转移（因为含根节点$j$的连通块要有一个黑点）；如果连通，子树的连通部分不能含任何黑点！，即$dp[j][0]$。通过加法原理（为什么？我的理解就是因为这两种情况不可共存，互相约束）将两种方案数相加，得到一棵子树的方案数。再用乘法原理（同上，每颗子树互相之间没有约束，情况可以共存）将各个子树的方案数相乘，得到总方案数。即：

$$dp[i][0] = 0$$
$$dp[i][1] = \prod_{j}^{j是i的儿子}(dp[j][0] + dp[j][1])$$
2）根为白点时：当你求 $dp[i][0]$时，同根为黑点时的 $dp[i][1]$情况一般：如果不连通，子树要 自力更生即通过状态 $dp[j][1]$转移（因为含根节点 $j$的连通块要有一个黑点）；如果连通，子树的连通部分不能含任何黑点！，即$dp[j][0]$【对我就是复制的2333】。
但！！！ $dp[i][1]$是个难搞的状态。回到我们上面的讨论，“包含根节点那个连通块内的黑点，来源有三处：它的子树，它本身，它的父亲以上”。此处既不是它本身，也不与它父节点相关。那只能是在它的子树里 选且只选一个子树，并让其连通根节点。假设其为 $k$，我们可以得到如下的转移：
$$dp[i][1] =\frac{\prod_{j}^{j是i的儿子}(dp[j][0] + dp[j][1])}{dp[k][0] + dp[k][1]} * dp[k][1]$$
多么美好的想法啊！
可惜在模运算的情况下，除法是行不通的。 只能逆元。
尽管学长说，逆元写习惯了，没啥子问题。但是我内心还是拒绝的。但是，利用累乘的思想，我们可以提出以下的状态转移：
令前 $k-1$颗子树中，与根连通部分不含黑点的方案数为 $f1$，与根连通部分含一个黑点的方案数为 $f2$
对于第 $k$颗子树，若它被选中了！它必须连通且含有一颗黑点，则方案数为$f1*dp[k][1]$
若它不幸没有入选……它可不连通 自力更生，或连通但洗白自己，方案数为 $f2*(dp[k][0]+dp[k][1])$
不断维护 $f2=f1*dp[k][1]+f2*(dp[k][0]+dp[k][1])$， $f1=f1*(dp[k][0]+dp[k][1])$（ 一定要先维护f2，重点强调！！！！），最终 $f2$就是我们的 $dp[i][1]$
其实我们发现， $f1$也就是我们的 $dp[i][0]$，所以 $f1$与 $f2$根本不需要真实出现，只是我们脑中用于辅助的思想。然后就可以码代码了。

@这里是代码@

各位实在不懂……就只能依靠自己的代码阅读能力咯￣ω￣=

#include<cstdio>
#include<vector>
using namespace std;
const long long MOD = 1000000000ll + 7;
const int MAXN = 100000;
vector<int>G[MAXN + 5];
long long dp[MAXN + 5][4], r[MAXN + 5];
int col[MAXN + 5];
int N, P;
void dfs(int x,int pre) {
    dp[x][0] = dp[x][1] = 1;
    if( col[x] == 1 ) {
        dp[x][0] = 0;
        for(int i=0;i<G[x].size();i++) {
            int p = G[x][i];
            if( p == pre )
                continue;
            dfs(p, x);
            dp[x][1] = dp[x][1] * (dp[p][1] + dp[p][0]) % MOD;
        }
    }
    else {
        dp[x][1] = 0;
        for(int i=0;i<G[x].size();i++) {
            int p = G[x][i];
            if( p == pre )
                continue;
            dfs(p, x);
            dp[x][1] = (dp[x][1] * (dp[p][0] + dp[p][1])%MOD + (dp[x][0] * dp[p][1]))%MOD;
            dp[x][0] = dp[x][0] * (dp[p][0] + dp[p][1])%MOD;
        }
    }
}
int main() {
    scanf("%d",&N);
    for(int i=0;i<N-1;i++) {
        scanf("%d",&P);
        G[P].push_back(i+1);
        G[i+1].push_back(P);
    }
    for(int i=0;i<N;i++)
        scanf("%d",&col[i]);
    dfs(0, -1);
    printf("%lld\n",dp[0][1]);
}

---

@大致总结一下@

这道题模板性很强，且是dp特别是树形dp中比较少见的计数性问题【因为dp一般都是最优化问题】，算是可供积累的好题。一些技巧：1）反复用于计数问题特有的加法原理与乘法原理求解，2）当涉及模运算中的“除法”时——逆元时，深入想想，用累乘巧妙跳过了复杂的实现。
累乘也算是树dp一种技巧，用得好可以简化代码的复杂度，但也要想很久才能保证正确。

@END.@

就是这样，新的一天里，也请多多关照哦(ノω<。)ノ))☆.。~