Optimal alpha beta pruning

Fox Ciel is developing an artificial intelligence (AI) for a game. The game is described as a game tree $T$ with $n$ vertices. Each node has an evaluation value that shows how good a situation is. The value of a non-leaf node is the maximum of its children's values multiplied by $-1$. Leaf values are computed with Ciel's special function, which is heavy to evaluate. So Ciel uses alpha-beta pruning to compute the root's evaluation value while reducing the number of leaf nodes that are evaluated.

The order in which child nodes are evaluated changes how many leaf nodes are computed. Ciel wants the minimum and the maximum number of leaf evaluations she can get when she may evaluate the children of each node in any order. Ciel uses the following algorithm.

function negamax(node, α, β)
    if node is a terminal node
        return value of leaf node
    else
        foreach child of node
            val := -negamax(child, -β, -α)
            if val >= β
                return val
            if val > α
                α := val
        return α

negamax algorithm

The first line contains an integer $n$, the number of vertices in the game tree $T$. The second line contains $n$ integers $p_i$, the evaluation value of vertex $i$. The next $n$ lines describe the tree. $k_i$ is the number of children of vertex $i$, followed by the child indices $t_{ij}$.

n
p1 p2 ... pn
k1 t11 t12 ... t1k
:
:
kn tn1 tn2 ... tnk

• $2 \le n \le 100$
• $-10000 \le p_i \le 10000$
• $0 \le k_i \le 5$
• $2 \le t_{ij} \le n$
• The root is vertex $1$.
• The evaluation value of a non-leaf node is always $0$ in the input. You must compute it when needed.
• A leaf node may also have value $0$.
• The game tree is a tree structure.

Print the minimum and the maximum number of leaf evaluations, separated by a space.

minimum maximum