Count Nodes With the Highest Score

Count Nodes With the Highest Score - Problem

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

Input & Output

Example 1 — Basic Tree

$ Input: parents = [-1,0,0,1,1]

› Output: 3

💡 Note: Tree: 0 has children [1,2], node 1 has children [3,4]. Removing node 1 gives score 2×1×1=2. Removing nodes 3,4,2 each give score 4×1=4. Three nodes have the highest score 4.

Example 2 — Single Node

$ Input: parents = [-1]

› Output: 1

💡 Note: Only one node exists. Removing it leaves no subtrees, so score is 1 (by definition). One node has the highest score.

Example 3 — Linear Tree

$ Input: parents = [-1,0,1]

› Output: 2

💡 Note: Linear tree 0-1-2. Removing node 1 gives score 1×1=1. Removing nodes 0 or 2 gives score 2×1=2. Two nodes have the highest score 2.

Constraints

2 ≤ parents.length ≤ 10⁵
parents[0] == -1
0 ≤ parents[i] ≤ n - 1 for i != 0
parents represents a valid tree

Visualization

Tap to expand

Asked in

M Microsoft 35 a Amazon 28 G Google 22

The key insight is to use DFS to precompute all subtree sizes in O(n) time, then calculate each node's removal score using the formula: product of child subtree sizes × upper subtree size. Best approach is DFS with memoization. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Remove Each Node

⏱️ Time: O(n²) Space: O(n)

Remove each node one by one, then traverse the remaining forest to count the sizes of all resulting subtrees. Calculate the product for each removal.

DFS with Subtree Size Calculation

⏱️ Time: O(n) Space: O(n)

Use DFS to calculate the size of each subtree in one pass. For each node removal, we know the sizes of child subtrees and can calculate the upper part size.

Brute Force - Remove Each Node — Algorithm Steps

For each node, create a copy of the tree
Remove the node and its edges
Count sizes of all remaining subtrees
Calculate product of sizes

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick Node to Remove

Choose a node to remove from tree

Count Subtrees

Count sizes of all resulting subtrees

Calculate Score

Multiply all subtree sizes together

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int countSubtreeSize(int node, int** children, int* childrenCount, int avoid) {
    if (node == avoid) return 0;
    int size = 1;
    for (int i = 0; i < childrenCount[node]; i++) {
        size += countSubtreeSize(children[node][i], children, childrenCount, avoid);
    }
    return size;
}

int solution(int* parents, int n) {
    if (n == 1) return 1;
    
    // Build adjacency list
    int** children = (int**)malloc(n * sizeof(int*));
    int* childrenCount = (int*)calloc(n, sizeof(int));
    
    // Count children for each node
    for (int i = 1; i < n; i++) {
        childrenCount[parents[i]]++;
    }
    
    // Allocate memory for children arrays
    for (int i = 0; i < n; i++) {
        children[i] = (int*)malloc(childrenCount[i] * sizeof(int));
        childrenCount[i] = 0; // Reset for filling
    }
    
    // Fill children arrays
    for (int i = 1; i < n; i++) {
        children[parents[i]][childrenCount[parents[i]]++] = i;
    }
    
    long long maxScore = 0;
    int count = 0;
    
    // Try removing each node
    for (int removeNode = 0; removeNode < n; removeNode++) {
        int subtreeSizes[n];
        int subtreeCount = 0;
        
        if (removeNode == 0) {
            for (int i = 0; i < childrenCount[0]; i++) {
                int size = countSubtreeSize(children[0][i], children, childrenCount, removeNode);
                if (size > 0) subtreeSizes[subtreeCount++] = size;
            }
        } else {
            int removedSubtreeSize = countSubtreeSize(removeNode, children, childrenCount, -1);
            int upperSize = n - removedSubtreeSize;
            if (upperSize > 0) subtreeSizes[subtreeCount++] = upperSize;
            
            for (int i = 0; i < childrenCount[removeNode]; i++) {
                int size = countSubtreeSize(children[removeNode][i], children, childrenCount, removeNode);
                if (size > 0) subtreeSizes[subtreeCount++] = size;
            }
        }
        
        long long score = 1;
        for (int i = 0; i < subtreeCount; i++) {
            score *= subtreeSizes[i];
        }
        
        if (score > maxScore) {
            maxScore = score;
            count = 1;
        } else if (score == maxScore) {
            count++;
        }
    }
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(children[i]);
    }
    free(children);
    free(childrenCount);
    
    return count;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse array manually
    int parents[10000];
    int n = 0;
    char* token = strtok(line + 1, ",]"); // Skip '['
    while (token != NULL) {
        parents[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(parents, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we traverse the tree to count subtree sizes

✓ Linear Growth

Space Complexity

O(n)

Need to store tree structure and visited arrays

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Remove Each Node — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler