LeetCode 2049. Count Nodes With the Highest Score

原题链接在这里：https://leetcode.com/problems/count-nodes-with-the-highest-score/description/

题目：

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

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

Return the number of nodes that have the highest score.

Example 1:

Input: parents = [-1,2,0,2,0]
Output: 3
Explanation:
- 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.

Example 2:

Input: parents = [-1,2,0]
Output: 2
Explanation:
- 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.

Constraints:

• n == parents.length
• 2 <= n <= 105
• parents[0] == -1
• 0 <= parents[i] <= n - 1 for i != 0
• parents represents a valid binary tree.

题解：

For each node, there are at most 3 edges, left, right, and up. Product is to multiply the nodes in the 3 components.

Then we need to know how many nodes are in each component, we could count the nodes using DFS bottom up.

For up component, its count = n - leftCount - rightCount - 1. But for root, it could be 0, we need make sure it is at least 1.

And keep updating the maximum product and result.

Time Complexity: O(n). n = parents.length.

Space: O(n).

AC Java:

class Solution {
    int res = 0;
    long max = 1;
    public int countHighestScoreNodes(int[] parents) {
        int n = parents.length;
        List<Integer>[] graph = new ArrayList[n];
        for(int i = 0; i < n; i++){
            graph[i] = new ArrayList<>();
        }

        for(int i = 1; i < n; i++){
            graph[parents[i]].add(i);
        }

        dfs(graph, 0, n);
        return res;
    }

    private int dfs(List<Integer>[] graph, int node, int n){
        int total = 0;
        long product = 1L;
        for(int next : graph[node]){
            int count = dfs(graph, next, n);
            total += count;
            product *= count;
        }

        product *= Math.max(1, n - total - 1);
        if(product > max){
            max = product;
            res = 1;
        }else if(product == max){
            res++;
        }

        return total + 1;
    }
}