<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>

class Solution:
    def countHighestScoreNodes(self, parents: List[int]) -> int:
    # Looks like getting the number of connected components each time a node is removed

        # Original graph -> graph = {0: [2, 4], 1: [2], 2: [0, 1, 3], 3: [2], 4: [0]}

        # Removed 0: graph = {1: [2], 2: [1, 3], 3: [2], 4: []}
        # Removed 1: graph = {0: [2, 4], 2: [0, 3], 3: [2], 4: [0]}
        # Removed 2: graph = {0: [4], 1: [], 3: [], 4: [0]}
        # Removed 3: graph = {0: [2, 4], 1: [2], 2: [0, 1], 4: [0]}
        # Removed 4: graph = {0: [2], 1: [2], 2: [0, 1, 3], 3: [2]}

        # 1 - Building graph
        graph = collections.defaultdict(set)
        for node, parent in enumerate(parents):  # build graph
            graph[parent].add(node)

        n = len(parents)                  # total number of nodes
        d = collections.Counter()         # Counter Hashmap
        # print(graph)                      # defaultdict(<class 'set'>, {-1: {0}, 2: {1, 3}, 0: {2, 4}})

        # 2 - Compute the size of each subtree rooted at node
        # in the process, we also store the score of each node

        def count_nodes(node):                   # number of children node + self
            p, s = 1, 0                          # p: product, s: sum
            for child in graph[node]:            # for each child (only 2 at maximum)
                res = count_nodes(child)         # get its nodes count
                p *= res                         # take the product
                s += res                         # take the sum
            
            p *= max(1, n - 1 - s)               # times up-branch (number of nodes other than left, right children ans itself)
            d[p] += 1                            # count the product
            
            return s + 1         

        # 3 - do fn call and return
        count_nodes(0)                       # starting from root (0)
        # print(d)
        return d[max(d.keys())]              # return max count

        # Time Complexity: O(N + E)
        # Space Complexity: O(N + E)

75077