Count Nodes With the Highest Score - Practice Coding Problems

Count Nodes With the Highest Score - Problem

Imagine you're a tree surgeon tasked with analyzing a special binary tree structure! 🌳

You have a binary tree rooted at node 0 with n nodes labeled from 0 to n-1. The tree structure is given as a parents array where parents[i] represents the parent of node i. Since node 0 is the root, parents[0] = -1.

Here's the interesting part: each node has a score calculated by a unique method. To find a node's score, imagine removing that node and all edges connected to it. This splits the tree into one or more separate subtrees. The node's score is the product of the sizes of all resulting subtrees.

Your goal: Find how many nodes achieve the maximum possible score.

Example: If removing a node creates subtrees of sizes [2, 3, 1], the score would be 2 × 3 × 1 = 6.

Input & Output

example_1.py — Basic Tree

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

› Output: 3

💡 Note: Tree structure: 0 is root with children 2. Node 2 has children 1 and 3. Removing nodes 1, 2, or 3 gives the maximum score of 4, so answer is 3.

example_2.py — Single Node

$ Input: parents = [-1]

› Output: 1

💡 Note: Only one node (root). Removing it creates no subtrees, so score is 1. Only 1 node achieves this maximum score.

example_3.py — Linear Tree

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

› Output: 2

💡 Note: Linear tree: 0->1->2->3. Removing node 1 or 2 gives maximum score by creating more balanced partitions.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Build Tree Structure

Convert parent array into adjacency list representation

Calculate Subtree Sizes

Use DFS to find size of subtree rooted at each node

Compute Node Scores

For each node, score = product of all resulting component sizes

Track Maximum

Count how many nodes achieve the highest possible score

Key Takeaway

🎯 Key Insight: When removing a node, the resulting components are its child subtrees plus the remaining upper portion of the tree. Calculate efficiently using pre-computed subtree sizes!

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses a single DFS traversal to calculate subtree sizes, then computes each node's score using the key insight that removing a node creates components of sizes: child subtrees × remaining upper part. This achieves O(n) time complexity compared to the brute force O(n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recalculate for Each Node)	O(n²)	O(n)	For each node, rebuild subtrees and calculate sizes from scratch
Single DFS Pass (Optimal)	O(n)	O(n)	Calculate subtree sizes in one DFS, then compute scores using mathematical relationship

Brute Force (Recalculate for Each Node) — Algorithm Steps

Build the tree structure from the parents array
For each node, temporarily remove it and its edges
Perform DFS/BFS to find all connected components (subtrees)
Calculate the product of all subtree sizes
Track the maximum score and count of nodes achieving it

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Tree

Start with the complete tree structure

Remove Node

Remove a node and all its connections

Find Components

Identify all disconnected subtrees

Calculate Score

Multiply sizes of all components

Code -

solution.c — C

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

typedef struct {
    int* data;
    int size;
    int capacity;
} IntList;

IntList* createList() {
    IntList* list = malloc(sizeof(IntList));
    list->data = malloc(sizeof(int) * 10);
    list->size = 0;
    list->capacity = 10;
    return list;
}

void addToList(IntList* list, int value) {
    if (list->size >= list->capacity) {
        list->capacity *= 2;
        list->data = realloc(list->data, sizeof(int) * list->capacity);
    }
    list->data[list->size++] = value;
}

int dfsSize(int node, IntList* children[], bool* visited, int removed, int n) {
    if (node == removed || visited[node]) return 0;
    visited[node] = true;
    int size = 1;
    
    for (int i = 0; i < children[node]->size; i++) {
        size += dfsSize(children[node]->data[i], children, visited, removed, n);
    }
    return size;
}

long long calculateScore(int removed, IntList* children[], int n) {
    bool* visited = calloc(n, sizeof(bool));
    visited[removed] = true;
    int components[n];
    int compCount = 0;
    
    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            int size = dfsSize(i, children, visited, removed, n);
            if (size > 0) {
                components[compCount++] = size;
            }
        }
    }
    
    free(visited);
    
    if (compCount == 0) return 1;
    
    long long score = 1;
    for (int i = 0; i < compCount; i++) {
        score *= components[i];
    }
    return score;
}

int countHighestScoreNodes(int* parents, int parentsSize) {
    int n = parentsSize;
    IntList* children[n];
    
    for (int i = 0; i < n; i++) {
        children[i] = createList();
    }
    
    for (int i = 1; i < n; i++) {
        addToList(children[parents[i]], i);
    }
    
    long long maxScore = 0;
    int count = 0;
    
    for (int removed = 0; removed < n; removed++) {
        long long score = calculateScore(removed, children, n);
        if (score > maxScore) {
            maxScore = score;
            count = 1;
        } else if (score == maxScore) {
            count++;
        }
    }
    
    for (int i = 0; i < n; i++) {
        free(children[i]->data);
        free(children[i]);
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we perform a complete tree traversal taking O(n) time

⚠ Quadratic Growth

Space Complexity

O(n)

Space for building the tree structure and recursion stack

⚡ Linearithmic Space

32.4K Views

Medium-High Frequency

~25 min Avg. Time

856 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 (Recalculate for Each Node) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler