Number Of Ways To Reconstruct A Tree - Practice Coding Problems

Number Of Ways To Reconstruct A Tree - Problem

Tree Graph Hard

The Tree Detective Challenge

Imagine you're a detective who discovered fragments of a family tree! You have a collection of pairs where each pair [xi, yi] tells you that two people are either ancestor-descendant or descendant-ancestor of each other in some family tree.

Your mission: determine how many different valid family trees can be constructed from these clues!

🔍 The Rules:
• The tree contains exactly the people mentioned in the pairs
• A pair [xi, yi] exists if and only if one person is an ancestor of the other
• Each tree has exactly one root (the oldest ancestor)
• All relationships flow from root to descendants

🎯 Your Task: Return 0 if impossible, 1 if exactly one tree exists, or 2 if multiple trees are possible.

Note: Trees don't need to be binary - a person can have any number of children!

Input & Output

example_1.py — Basic Tree

$ Input: pairs = [[1,2],[2,3],[1,3]]

› Output: 2

💡 Note: Multiple trees possible: Root can be 1 (with 2,3 as children and 2→3) or root can be 2 (with 1,3 as children). Both form valid trees with the given ancestor relationships.

example_2.py — Unique Tree

$ Input: pairs = [[1,2],[2,3],[2,4]]

› Output: 1

💡 Note: Only one tree structure possible: 2 must be the root (highest degree), with 1, 3, 4 as its children. Any other root arrangement would violate the pair constraints.

Constraints

Asked in

Common Approaches

Approach	Time	Space	Notes
✓ Graph-Based Validation Approach	O(n³)	O(n²)	Build adjacency graph, validate tree properties, and count valid structures

Graph-Based Validation Approach — Algorithm Steps

Build adjacency graph from pairs
Check if graph forms a valid tree structure
Validate degree constraints for tree properties
Use DFS to explore possible root candidates
Count distinct valid tree formations

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency representation from pairs

Check Tree Properties

Verify edge count and connectivity constraints

Find Root Candidates

Identify nodes that could serve as tree roots

Validate Each Root

For each candidate, check if it forms valid tree

Code -

solution.c — C

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

#define MAX_NODES 1000

typedef struct {
    bool adj[MAX_NODES][MAX_NODES];
    int nodes[MAX_NODES];
    int nodeCount;
    int nodeMap[MAX_NODES];
} Graph;

bool dfs(int node, int par, Graph* g, bool visited[], int parent[]) {
    visited[node] = true;
    for (int i = 0; i < g->nodeCount; i++) {
        int neighbor = g->nodes[i];
        if (g->adj[node][neighbor] && neighbor != par && !visited[neighbor]) {
            parent[neighbor] = node;
            if (!dfs(neighbor, node, g, visited, parent)) {
                return false;
            }
        }
    }
    return true;
}

bool isAncestor(int a, int b, int parent[]) {
    int current = b;
    while (parent[current] != -1) {
        current = parent[current];
        if (current == a) return true;
    }
    return false;
}

bool canFormTreeWithRoot(int root, Graph* g, int pairs[][2], int pairCount) {
    bool visited[MAX_NODES] = {false};
    int parent[MAX_NODES];
    for (int i = 0; i < MAX_NODES; i++) parent[i] = -1;
    
    if (!dfs(root, -1, g, visited, parent)) {
        return false;
    }
    
    // Count visited nodes
    int visitedCount = 0;
    for (int i = 0; i < g->nodeCount; i++) {
        if (visited[g->nodes[i]]) visitedCount++;
    }
    
    if (visitedCount != g->nodeCount) {
        return false;
    }
    
    // Simple validation (in practice would need more complex logic)
    return true;
}

int checkWays(int pairs[][2], int pairCount) {
    Graph g;
    g.nodeCount = 0;
    
    // Initialize
    for (int i = 0; i < MAX_NODES; i++) {
        g.nodeMap[i] = -1;
        for (int j = 0; j < MAX_NODES; j++) {
            g.adj[i][j] = false;
        }
    }
    
    // Build graph
    for (int i = 0; i < pairCount; i++) {
        int x = pairs[i][0], y = pairs[i][1];
        
        // Add nodes if not exist
        bool xFound = false, yFound = false;
        for (int j = 0; j < g.nodeCount; j++) {
            if (g.nodes[j] == x) xFound = true;
            if (g.nodes[j] == y) yFound = true;
        }
        
        if (!xFound) {
            g.nodes[g.nodeCount] = x;
            g.nodeMap[x] = g.nodeCount;
            g.nodeCount++;
        }
        if (!yFound) {
            g.nodes[g.nodeCount] = y;
            g.nodeMap[y] = g.nodeCount;
            g.nodeCount++;
        }
        
        g.adj[x][y] = g.adj[y][x] = true;
    }
    
    // Check tree property
    if (pairCount != g.nodeCount - 1) {
        return 0;
    }
    
    int validRootCount = 0;
    for (int i = 0; i < g.nodeCount; i++) {
        int root = g.nodes[i];
        if (canFormTreeWithRoot(root, &g, pairs, pairCount)) {
            validRootCount++;
        }
    }
    
    return validRootCount == 0 ? 0 : validRootCount == 1 ? 1 : 2;
}

int main() {
    int n;
    scanf("%d", &n);
    int pairs[1000][2];
    for (int i = 0; i < n; i++) {
        scanf("%d %d", &pairs[i][0], &pairs[i][1]);
    }
    printf("%d\n", checkWays(pairs, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Building graph O(n²) + validation O(n) + tree enumeration O(n²)

⚠ Quadratic Growth

Space Complexity

O(n²)

Space for adjacency matrix and validation structures

⚠ Quadratic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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