Count Nodes That Are Great Enough

Count Nodes That Are Great Enough - Problem

Count Nodes That Are Great Enough

You are given the root of a binary tree and an integer k. Your task is to identify and count all the "great enough" nodes in the tree.

A node is considered great enough if it satisfies both of these conditions:
1. Size condition: Its subtree contains at least k nodes (including itself)
2. Value condition: Its value is greater than the values of at least k nodes in its subtree

Note that a node is considered to be in its own subtree. A subtree of node v includes v itself and all nodes that have v as an ancestor.

Goal: Return the total count of nodes that meet both criteria.

Example: If k = 2, a node needs to have at least 2 nodes in its subtree AND its value must be greater than at least 2 values in that subtree.

Input & Output

example_1.py — Basic Tree

$ Input: root = [5,3,7,1,4,null,null], k = 2

› Output: 1

💡 Note: Node 5 has subtree [5,3,7,1,4] with size 5 ≥ 2 and values [1,3,4] are smaller than 5, so 3 ≥ 2. Node 3 has subtree [3,1,4] with size 3 ≥ 2 but only 1 value is smaller than 3, so 1 < 2. Other nodes have subtree size < 2. Only node 5 qualifies.

example_2.py — Single Node

$ Input: root = [10], k = 1

› Output: 0

💡 Note: Single node with value 10. Subtree has 1 node ≥ 1, but there are 0 nodes smaller than 10 in its subtree, and 0 < 1, so it doesn't qualify.

example_3.py — Large k

$ Input: root = [1,2,3], k = 5

› Output: 0

💡 Note: No node has a subtree with at least 5 nodes, so no nodes can be great enough regardless of value conditions.

Constraints

1 ≤ number of nodes ≤ 10⁴
1 ≤ Node.val ≤ 10⁴
1 ≤ k ≤ 10⁴
All node values are unique

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal approach uses single-pass DFS with bottom-up processing to collect subtree information efficiently. Each node gathers values from its children's subtrees, evaluates both size condition (≥ k nodes) and value condition (value greater than ≥ k nodes), then passes complete subtree data upward. This avoids redundant traversals while maintaining O(n) tree processing time.

Common Approaches

✓ Memoization

⏱️ Time: N/A Space: N/A

Single-Pass DFS with Subtree Information

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

Process the tree using post-order traversal (bottom-up), where each node collects complete subtree information from its children. For each node, we gather all values in its subtree and determine both size and ranking efficiently.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

typedef struct {
    int size;
    int* values;
    int valueCount;
} SubtreeInfo;

typedef struct {
    TreeNode* node;
    SubtreeInfo info;
} MemoEntry;

static MemoEntry memo[10000];
static int memoSize = 0;

TreeNode* createNode(int val) {
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

SubtreeInfo* findInMemo(TreeNode* node) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].node == node) {
            return &memo[i].info;
        }
    }
    return NULL;
}

void addToMemo(TreeNode* node, SubtreeInfo info) {
    if (memoSize < 10000) {
        memo[memoSize].node = node;
        memo[memoSize].info = info;
        memoSize++;
    }
}

SubtreeInfo getSubtreeInfo(TreeNode* node) {
    SubtreeInfo emptyInfo = {0, NULL, 0};
    if (!node) {
        return emptyInfo;
    }
    
    SubtreeInfo* cached = findInMemo(node);
    if (cached) {
        return *cached;
    }
    
    SubtreeInfo leftInfo = getSubtreeInfo(node->left);
    SubtreeInfo rightInfo = getSubtreeInfo(node->right);
    
    int subtreeSize = 1 + leftInfo.size + rightInfo.size;
    int* subtreeValues = (int*)malloc(subtreeSize * sizeof(int));
    
    int idx = 0;
    subtreeValues[idx++] = node->val;
    
    for (int i = 0; i < leftInfo.valueCount; i++) {
        subtreeValues[idx++] = leftInfo.values[i];
    }
    
    for (int i = 0; i < rightInfo.valueCount; i++) {
        subtreeValues[idx++] = rightInfo.values[i];
    }
    
    SubtreeInfo result = {subtreeSize, subtreeValues, subtreeSize};
    addToMemo(node, result);
    return result;
}

int countGreatNodes(TreeNode* node, int k) {
    if (!node) return 0;
    
    SubtreeInfo info = getSubtreeInfo(node);
    
    int count = 0;
    
    if (info.size >= k) {
        int smallerCount = 0;
        for (int i = 0; i < info.valueCount; i++) {
            if (info.values[i] < node->val) {
                smallerCount++;
            }
        }
        if (smallerCount >= k) {
            count = 1;
        }
    }
    
    count += countGreatNodes(node->left, k);
    count += countGreatNodes(node->right, k);
    
    return count;
}

TreeNode* buildTreeFromArray(char* input) {
    if (strcmp(input, "[]") == 0) {
        return NULL;
    }
    
    // Remove brackets
    char* cleaned = input + 1;
    cleaned[strlen(cleaned) - 1] = '\0';
    
    if (strlen(cleaned) == 0) {
        return NULL;
    }
    
    // Parse first value
    char* token = strtok(cleaned, ",");
    if (!token || strcmp(token, "null") == 0) {
        return NULL;
    }
    
    TreeNode* root = createNode(atoi(token));
    TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    while (front < rear) {
        TreeNode* node = queue[front++];
        
        // Left child
        token = strtok(NULL, ",");
        if (token && strcmp(token, "null") != 0 && strlen(token) > 0) {
            node->left = createNode(atoi(token));
            queue[rear++] = node->left;
        }
        
        // Right child
        token = strtok(NULL, ",");
        if (token && strcmp(token, "null") != 0 && strlen(token) > 0) {
            node->right = createNode(atoi(token));
            queue[rear++] = node->right;
        }
    }
    
    return root;
}

int main() {
    char input[1000];
    int k;
    
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    scanf("%d", &k);
    
    memoSize = 0;
    TreeNode* root = buildTreeFromArray(input);
    int result = countGreatNodes(root, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

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