Codeforces Round #551 (Div. 2) D. Serval and Rooted Tree(dp)

D. Serval and Rooted Tree
time limit per test2 seconds
memory limit per test256 megabytes
inputstandard input
outputstandard output
Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before.

As a talented boy in mathematics, he likes to play with numbers. This time, he wants to play with numbers on a rooted tree.

A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a node v is the last different from v vertex on the path from the root to the vertex v. Children of vertex v are all nodes for which v is the parent. A vertex is a leaf if it has no children.

The rooted tree Serval owns has n nodes, node 1 is the root. Serval will write some numbers into all nodes of the tree. However, there are some restrictions. Each of the nodes except leaves has an operation max or min written in it, indicating that the number in this node should be equal to the maximum or minimum of all the numbers in its sons, respectively.

Assume that there are k leaves in the tree. Serval wants to put integers 1,2,…,k to the k leaves (each number should be used exactly once). He loves large numbers, so he wants to maximize the number in the root. As his best friend, can you help him?

Input
The first line contains an integer n (2≤n≤3⋅105), the size of the tree.

The second line contains n integers, the i-th of them represents the operation in the node i. 0 represents min and 1 represents max. If the node is a leaf, there is still a number of 0 or 1, but you can ignore it.

The third line contains n−1 integers f2,f3,…,fn (1≤fi≤i−1), where fi represents the parent of the node i.

Output
Output one integer — the maximum possible number in the root of the tree.

Examples
inputCopy
6
1 0 1 1 0 1
1 2 2 2 2
outputCopy
1
inputCopy
5
1 0 1 0 1
1 1 1 1
outputCopy
4
inputCopy
8
1 0 0 1 0 1 1 0
1 1 2 2 3 3 3
outputCopy
4
inputCopy
9
1 1 0 0 1 0 1 0 1
1 1 2 2 3 3 4 4
outputCopy
5
Note
Pictures below explain the examples. The numbers written in the middle of the nodes are their indices, and the numbers written on the top are the numbers written in the nodes.

In the first example, no matter how you arrange the numbers, the answer is 1.

In the second example, no matter how you arrange the numbers, the answer is 4.

In the third example, one of the best solution to achieve 4 is to arrange 4 and 5 to nodes 4 and 5.

In the fourth example, the best solution is to arrange 5 to node 5.

解析

dp[i]表示这个节点的值在其子节点的所有值的排序

如果一个树结构是确定的话
为了使根节点的值最大，dp就是确定的

两种更新方式
如果是节点类型min，那么这个节点的值就是最小的
就让根节点的值等于子节点的dp值加起来即可
如果节点类型是max，那么这个节点的值就是最大的
这时候dp的最小值即可（因为dp[i]表示这个节点的值在其子节点的所有值的排序 ）

code

#include <bits/stdc++.h>

using namespace std;
const int N=3e5+10;
int ar[N];
int dp[N];//表示这个节点的值在其子节点的所有值的排序
vector<int>G[N];
int num=0;
void dfs(int x ){
    if(G[x].size()==0){
        dp[x]=1;
        num++;
        return ;
    }
    for(int i=0;i<G[x].size();i++){
        int y=G[x][i];
        dfs(y);
        if(ar[x]){
            if(dp[x]==0)
                dp[x]=dp[y];
            else
                dp[x]=min(dp[x],dp[y]);

        }
        else {
            dp[x]+=dp[y];
        }
    }
}
int main()
{
    ios::sync_with_stdio(0);
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>ar[i];
    }
    for(int i=2;i<=n;i++){
        int a ;
        cin>>a;
        G[a].push_back(i);
    }
    dfs(1);
    cout<<num+1-dp[1]<<endl;
    return 0;
}