Count Number of Possible Root Nodes - Practice Coding Problems

Count Number of Possible Root Nodes - Problem

Array Hash Table Dynamic Programming Tree Depth-First Search Hard

Imagine Alice has a beautiful undirected tree with n nodes labeled from 0 to n-1. The tree is represented as a 2D array edges where each edges[i] = [a_i, b_i] indicates there's an edge connecting nodes a_i and b_i.

Alice wants Bob to discover the root of her tree. She allows Bob to make educated guesses about parent-child relationships. In each guess, Bob:

Chooses two connected nodes u and v (where an edge exists between them)
Guesses that u is the parent of v in the rooted tree

Bob's guesses are represented by array guesses where guesses[j] = [u_j, v_j] means Bob thinks u_j is the parent of v_j.

Alice, being busy, doesn't check each guess individually. Instead, she simply tells Bob that at least k of his guesses are correct.

Your mission: Given the tree structure (edges), Bob's guesses (guesses), and the minimum correct guesses (k), determine how many different nodes could potentially be the root of Alice's tree.

Input & Output

example_1.py — Basic Tree

$ Input: edges = [[0,1],[1,2],[1,3],[4,2]], guesses = [[1,3],[0,1],[1,0],[2,4]], k = 3

› Output: 3

💡 Note: We have a tree with 5 nodes. Bob made 4 guesses about parent-child relationships. For this tree, nodes 0, 1, and 4 can be valid roots because each allows at least 3 correct guesses.

example_2.py — Simple Path

$ Input: edges = [[0,1],[1,2],[2,3]], guesses = [[0,1],[1,2],[2,3]], k = 2

› Output: 2

💡 Note: This is a simple path: 0-1-2-3. Only nodes 0 and 1 can be roots with at least 2 correct guesses. When 0 is root: (0→1), (1→2), (2→3) are all correct. When 1 is root: (1→2), (2→3) are correct.

example_3.py — High Threshold

$ Input: edges = [[0,1],[0,2]], guesses = [[0,1],[2,0]], k = 3

› Output: 0

💡 Note: This is a star with center 0. Bob guessed (0→1) and (2→0). No root can have 3 or more correct guesses since there are only 2 edges total, so the answer is 0.

Constraints

n == edges.length + 1
2 ≤ n ≤ 10⁵
1 ≤ guesses.length ≤ 10⁵
0 ≤ a_i, b_i < n
a_i != b_i
edges represents a valid tree
guesses[i] = [u_i, v_i] where there exists an edge between u_i and v_i
0 ≤ k ≤ guesses.length

Visualization

Tap to expand

Understanding the Visualization

Build Family Tree

Create the family connections from the edges

Test Leadership

For each potential family head, see how many guesses match reality

Efficient Transition

When changing leaders, smartly update the correct guess count

Count Valid Leaders

Count how many people could lead with at least k correct guesses

Key Takeaway

🎯 Key Insight: Use tree rerooting to efficiently test all possible roots by updating the correct guess count incrementally rather than recalculating from scratch.

Asked in

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

The optimal solution uses tree rerooting technique. Start with any node as root, count initial correct guesses, then efficiently update the count as we 'move' the root through DFS. When root moves from parent to child, we lose the (parent→child) guess but gain the (child→parent) guess if it exists. This achieves O(n) time complexity with a single tree traversal.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Roots)	O(n²)	O(n)	Test each node as root, build tree, count correct guesses
Tree Rerooting (Optimal)	O(n)	O(n)	Use tree rerooting technique to efficiently count valid roots in one pass

Brute Force (Try All Roots) — Algorithm Steps

Iterate through each node as a potential root
For each root, perform DFS to establish parent-child relationships
Count how many guesses match the actual relationships
If count >= k, increment the result
Return total count of valid roots

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Root

Select a node as potential root

Build Tree

Perform DFS to establish parent-child relationships

Count Matches

Compare actual relationships with Bob's guesses

Check Threshold

See if correct guesses >= k

Code -

solution.c — C

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

typedef struct {
    char key[20];
} GuessKey;

int adj[100001][100001];
int adjSize[100001];
GuessKey guessSet[100001];
int guessCount;

int hasGuess(int u, int v) {
    char key[20];
    sprintf(key, "%d,%d", u, v);
    for (int i = 0; i < guessCount; i++) {
        if (strcmp(guessSet[i].key, key) == 0) {
            return 1;
        }
    }
    return 0;
}

int dfs(int node, int parent) {
    int correct = 0;
    for (int i = 0; i < adjSize[node]; i++) {
        int neighbor = adj[node][i];
        if (neighbor != parent) {
            if (hasGuess(node, neighbor)) {
                correct++;
            }
            correct += dfs(neighbor, node);
        }
    }
    return correct;
}

int rootCount(int** edges, int edgesSize, int* edgesColSize, int** guesses, int guessesSize, int* guessesColSize, int k) {
    int n = edgesSize + 1;
    
    // Initialize adjacency list
    memset(adjSize, 0, sizeof(adjSize));
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        adj[u][adjSize[u]++] = v;
        adj[v][adjSize[v]++] = u;
    }
    
    // Build guess set
    guessCount = guessesSize;
    for (int i = 0; i < guessesSize; i++) {
        sprintf(guessSet[i].key, "%d,%d", guesses[i][0], guesses[i][1]);
    }
    
    int result = 0;
    for (int root = 0; root < n; root++) {
        int correctGuesses = dfs(root, -1);
        if (correctGuesses >= k) {
            result++;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) nodes to try as root × O(n) DFS traversal for each root

⚠ Quadratic Growth

Space Complexity

O(n)

O(n) for adjacency list and recursion stack depth

⚡ Linearithmic Space

38.5K Views

Medium Frequency

~25 min Avg. Time

1.4K 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 (Try All Roots) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler