CodeForces 461B Appleman and T

题目链接：http://codeforces.com/contest/461/problem/B

题目大意：

　　给定一课树，树上的节点有黑的也有白的，有这样一种分割树的方案，分割后每个子图只含有一个黑色节点，问这样的分割方案一共有多少种？

分析：

先定义3个函数（为了之后说起来方便）：

　　设A(x) = 在以顶点x为根的子树中，所有满足使x所在子图不含黑色顶点，其余子图只含有1个黑色顶点的分割方案种数 。
　　设B(x) = 在以顶点x为根的子树中，所有满足每个子图只含有1个黑色顶点的分割方案种数 。
　　设C(x) = 在以顶点x为根的子树中，所有满足使x所在子图只含有1个黑色顶点，其余子图只含有1个黑色顶点的分割方案种数 。

　　显然B(x) = C(x)

　　首先我们关注某一课子树的根节点，不妨设为rt，有2种情况：

　　不妨设rt有a个黑色的孩子节点，b个白色的孩子节点，rt的第i个黑色节点表示为rtB_i，白色节点表示为rtW_i，rt的第i个孩子节点表示为son_i

1 : color[rt] == WHITE

　　初始条件下B(rt) = 0

　　在这种情况下，rt与每个孩子节点都有相连与不相连2种策略，对于son_i，不相连的贡献自然是B(son_i)，而相连的贡献就不是独立的了，很可能有跨越根节点到其他子树的方案，也就是说，对于每一棵子树，都要和其他每一棵子树有深入交流。

　　我们可以考虑增而治之，设rtSons_i为以rt为根节点，只拥有前i个孩子节点的树，A(rt)，B(rt)，C(rt)为相应数值，初始状态为A(rt) = 1，B(rt) = 0，C(rt) = 0，我们只要考虑son_i+1加入时，A(rt)，B(rt)，C(rt)会如何变化，当子树全部加入时，就算完了。这里有2种情况：

　　（1）与son_i+1相连：B(rt)  = C(rt) = A(rt) * C(son_i+1) + C(rt) * A(son_i+1)

                                    A(rt) = A(rt) * A(son_i+1)

　　（2）与son_i+1不相连：B(rt)  = C(rt) = C(rt) * C(son_i+1)

                                        A(rt) = A(rt) * C(son_i+1)

　　于是总变化为：B(rt)  = C(rt) = A(rt) * C(son_i+1) + C(rt) * [A(son_i+1) + C(son_i+1)]

                           A(rt) = A(rt) * [A(son_i+1) + C(son_i+1)]

 

 

2：color[rt] == BLACK

　　初始条件下B(rt) = 1，自己自身算一个

　　在这种情况下，rt一定不能与黑色的孩子节点相连，而对于白色的孩子节点，有相连与不相连两种选择。

　　同样增而治之，设rtSons_i为以rt为根节点，只拥有前i个孩子节点的树，A(rt)，B(rt)，C(rt)为相应数值，初始状态为A(rt) = 0，B(rt) = 1，C(rt) = 1并且A(rt)恒等于0，我们只要考虑son_i+1加入时，A(rt)，B(rt)，C(rt)会如何变化，当子树全部加入时，就算完了。这里有3种情况：

　　（1）son_i+1为白色节点&&与son_i+1相连：B(rt)  = C(rt) = C(rt) * A(son_i+1)

　　（2）son_i+1为白色节点&&与son_i+1不相连：B(rt)  = C(rt) = C(rt) * C(son_i+1)

　　（3）son_i+1为黑色节点（和2是同一种情况）：B(rt)  = C(rt) = C(rt) * C(son_i+1)

　　于是总变化为：B(rt)  = C(rt) = C(rt) * [A(son_i+1) + C(son_i+1)]

 

一个优化：对于color[rt] == BLACK的情况，如果我们把rt看成是白色的，然后照此计算出A(rt)，B(rt)，C(rt)，那么以rt为根节点的子树的真实方案数，不就是A(rt)吗？这样的话就没有必要分情况了，在最后加个判断即可。

 

代码如下：

#include <bits/stdc++.h>
using namespace std;
 
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define For(i,s,t) for (int i = (s); i <= (t); ++i)
#define rFor(i,t,s) for (int i = (t); i >= (s); --i)
#define foreach(i,c) for (__typeof(c.begin()) i = c.begin(); i != c.end(); ++i)
#define rforeach(i,c) for (__typeof(c.rbegin()) i = c.rbegin(); i != c.rend(); ++i)
 
#define pr(x) cout << #x << " = " << x << "  "
#define prln(x) cout << #x << " = " << x << endl
 
#define LOWBIT(x) ((x)&(-x))
 
#define ALL(x) x.begin(),x.end()
#define INS(x) inserter(x,x.begin())
 
#define ms0(a) memset(a,0,sizeof(a))
#define msI(a) memset(a,inf,sizeof(a))
#define msM(a) memset(a,-1,sizeof(a))
 
#define pii pair<int,int> 
#define piii pair<pair<int,int>,int> 
#define mp make_pair
#define pb push_back
#define fi first
#define se second
 
inline int gc(){
    static const int BUF = 1e7;
    static char buf[BUF], *bg = buf + BUF, *ed = bg;
     
    if(bg == ed) fread(bg = buf, 1, BUF, stdin);
    return *bg++;
} 
 
inline int ri(){
    int x = 0, f = 1, c = gc();
    for(; c<48||c>57; f = c=='-'?-1:f, c=gc());
    for(; c>47&&c<58; x = x*10 + c - 48, c=gc());
    return x*f;
}
 
typedef long long LL;
typedef unsigned long long uLL;
const int inf = 1e9 + 9;
const LL mod = 1e9 + 7;
const int maxN = 1e5 + 7;
 
struct Node{
    vector< int > next;
};
 
int n, ans;
 
/*
    设A(x) = 在以顶点x为根的子树中，所有满足使x所在子图不含黑色顶点，其余子图只含有1个黑色顶点的分割方案种数 
    设B(x) = 在以顶点x为根的子树中，所有满足每个子图只含有1个黑色顶点的分割方案种数 
    设C(x) = 在以顶点x为根的子树中，所有满足使x所在子图只含有1个黑色顶点，其余子图只含有1个黑色顶点的分割方案种数 
    则有： 
        dp[v][0] = A(v) + B(v)
        dp[v][1] = B(v)
        C(v) = B(v)
    The answer is dp[0][1].
*/
LL dp[maxN][2];
Node nodes[maxN];
int color[maxN];
 
void dfs(int x) {
    // 默认顶点x为白色 
    dp[x][0] = 1;
    dp[x][1] = 0;
     
    foreach(i, nodes[x].next) {
        dfs(*i);
        // dp[*i][0] 包含 A(*i) 和 C(*i)，对于A(*i)，令其与C(x)相连
        // 而对于C(*i)，令其与C(x)分断 
        dp[x][1] = (dp[x][1] * dp[*i][0]) % mod;
        // dp[x][0] 包含 A(x)，令其与C(*i)相连
          dp[x][1] = (dp[x][1] + dp[x][0] * dp[*i][1]) % mod;
          // 此时dp[x][0] = A(x) 
          // dp[x][0] * dp[*i][0] = A(x)*A(*i) + A(x)*C(*i)
          // 依次是连接新子树的A(*i)部分和断掉新子树的C(*i)部分，两这都可以保证dp[x][0]更新后还是A(x) 
          dp[x][0] = (dp[x][0] * dp[*i][0]) % mod;
    }
     
    if(color[x] == 1) dp[x][1] = dp[x][0]; // 当根节点为黑色时，A(x)实际上是C(x)，而真正的A(x) = 0 
    else dp[x][0] = (dp[x][0] + dp[x][1]) % mod; // 此时 dp[x][0] = A(x) + C(x)
}
 
int main(){
    while(cin >> n) {
        rep(i, n) nodes[i].next.clear();
        For(i, 1, n-1) {
            int t;
            cin >> t;
            // 根据题目要求，并不需要加反向边 
            nodes[t].next.push_back(i);
        }
        rep(i, n) cin >> color[i];
         
        dfs(0);
         
        cout << dp[0][1] <<endl;
    }
    return 0;
}