<p>There is a <strong>binary</strong> tree rooted at <code>0</code> consisting of <code>n</code> nodes. The nodes are labeled from <code>0</code> to <code>n - 1</code>. You are given a <strong>0-indexed</strong> integer array <code>parents</code> representing the tree, where <code>parents[i]</code> is the parent of node <code>i</code>. Since node <code>0</code> is the root, <code>parents[0] == -1</code>.</p>

<p>Each node has a <strong>score</strong>. To find the score of a node, consider if the node and the edges connected to it were <strong>removed</strong>. The tree would become one or more <strong>non-empty</strong> subtrees. The <strong>size</strong> of a subtree is the number of the nodes in it. The <strong>score</strong> of the node is the <strong>product of the sizes</strong> of all those subtrees.</p>

<p>Return <em>the <strong>number</strong> of nodes that have the <strong>highest score</strong></em>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="example-1" src="https://assets.leetcode.com/uploads/2021/10/03/example-1.png" style="width: 604px; height: 266px;" />
<pre>
<strong>Input:</strong> parents = [-1,2,0,2,0]
<strong>Output:</strong> 3
<strong>Explanation:</strong>
- The score of node 0 is: 3 * 1 = 3
- The score of node 1 is: 4 = 4
- The score of node 2 is: 1 * 1 * 2 = 2
- The score of node 3 is: 4 = 4
- The score of node 4 is: 4 = 4
The highest score is 4, and three nodes (node 1, node 3, and node 4) have the highest score.
</pre>

<p><strong class="example">Example 2:</strong></p>
<img alt="example-2" src="https://assets.leetcode.com/uploads/2021/10/03/example-2.png" style="width: 95px; height: 143px;" />
<pre>
<strong>Input:</strong> parents = [-1,2,0]
<strong>Output:</strong> 2
<strong>Explanation:</strong>
- The score of node 0 is: 2 = 2
- The score of node 1 is: 2 = 2
- The score of node 2 is: 1 * 1 = 1
The highest score is 2, and two nodes (node 0 and node 1) have the highest score.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>n == parents.length</code></li>
	<li><code>2 &lt;= n &lt;= 10<sup>5</sup></code></li>
	<li><code>parents[0] == -1</code></li>
	<li><code>0 &lt;= parents[i] &lt;= n - 1</code> for <code>i != 0</code></li>
	<li><code>parents</code> represents a valid binary tree.</li>
</ul>

# 2024/09/19
# 面试前刷Doordash高频题目
# 
# Return the number of nodes that have the highest score.
# 这题如果给我root input，就很容易，三步法就行
# 首先就是根据input构建binary Tree，不难，hashmap: key = node id, value = TreeNode
# 因为已经告诉我们是n个node，且id连续，所以不用hashmap，list就行
# 然后就是三步法，需要global max，每个recursion返回当前subtree的node数量
# 
# 不对，题目没理解对，第一部分构建Tree还是没问题
# 第二部分不能用三步法来做
# 还是可以的
class TreeNode:
    def __init__(self, value):
        self.val = value
        self.left = None
        self.right = None

class Solution:
    def countHighestScoreNodes(self, parents: List[int]) -> int:
        nodes = [None] * len(parents)

        for i, p in enumerate(parents):
            if nodes[i] != None:
                node = nodes[i]
            else:
                node = TreeNode(i)
                nodes[i] = node
            
            if p == -1:
                continue

            if nodes[p] != None:
                parent = nodes[p]
            else:
                parent = TreeNode(p)
                nodes[p] = parent

            if parent.left is None:
                parent.left = node
            else:
                parent.right = node

        hashmap = collections.defaultdict(int)
        self.helper(nodes[0], hashmap, len(parents))

        max_score = max(hashmap.keys())

        return hashmap[max_score]

    
    def helper(self, root, hashmap, n):
        if root is None:
            return 0

        left = self.helper(root.left, hashmap, n)
        right = self.helper(root.right, hashmap, n)

        top_remaining = n - 1
        top_remaining -= left
        top_remaining -= right

        hashmap[max(1, top_remaining) * max(left, 1) * max(right, 1)] += 1 

        return 1 + left + right




43472