Number Of Ways To Reconstruct A Tree - Problem

Tree Graph Hard

You are given an array pairs, where pairs[i] = [xi, yi], and:

There are no duplicates.
xi < yi

Let ways be the number of rooted trees that satisfy the following conditions:

The tree consists of nodes whose values appeared in pairs.
A pair [xi, yi] exists in pairs if and only if xi is an ancestor of yi or yi is an ancestor of xi.
Note: the tree does not have to be a binary tree.

Two ways are considered to be different if there is at least one node that has different parents in both ways.

Return:

0 if ways == 0
1 if ways == 1
2 if ways > 1

A rooted tree is a tree that has a single root node, and all edges are oriented to be outgoing from the root.

An ancestor of a node is any node on the path from the root to that node (excluding the node itself). The root has no ancestors.

Input & Output

Example 1 — Complete Triangle

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

› Output: 1

💡 Note: All three nodes are connected to each other. There's exactly one way to form a tree: any node can be root with the other two as children, but the ancestor relationships determine a unique structure.

Example 2 — Linear Chain

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

› Output: 1

💡 Note: Forms a simple path 1-2-3. There's exactly one tree structure that satisfies the ancestor relationships.

Example 3 — Impossible Structure

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

› Output: 0

💡 Note: Two disconnected components cannot form a single tree. No valid tree structure exists.

Constraints

1 ≤ pairs.length ≤ 500
1 ≤ xi < yi ≤ 500
The elements in pairs are unique.

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 8

The key insight is to recognize this as a graph theory problem where we need to determine if a complete graph can be uniquely decomposed into a tree structure. Best approach uses graph validation with connectivity checks and degree analysis. Time: O(n²), Space: O(n²)

Common Approaches

✓ Brute Force Tree Generation

⏱️ Time: O(n! × 2ⁿ) Space: O(n²)

Try every possible root and tree configuration, then check if the resulting ancestor relationships match exactly with the given pairs.

Graph Theory Validation

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

Build a graph from pairs, check basic tree properties (n-1 edges, connectivity), then analyze node degrees and validate tree constraints without generating all possible trees.

Brute Force Tree Generation — Algorithm Steps

Step 1: Extract all unique nodes from pairs
Step 2: Try each node as potential root
Step 3: Generate all possible tree structures
Step 4: Validate ancestor relationships match pairs exactly

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Nodes

Find all unique nodes from pairs

Try Roots

Test each node as potential root

Validate

Check if tree matches given pairs

Code -

solution.c — C

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

static int pairs[1000][2];
static int pairsSize = 0;
static int nodes[1000];
static int nodeCount = 0;
static int adj[1000][1000];
static int adjCount[1000];
static char pairSet[10000][20];
static int pairSetSize = 0;

int compareInt(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int findNode(int val) {
    for (int i = 0; i < nodeCount; i++) {
        if (nodes[i] == val) return i;
    }
    return -1;
}

void addPair(int x, int y) {
    char pairStr[20];
    if (x < y) {
        sprintf(pairStr, "%d,%d", x, y);
    } else {
        sprintf(pairStr, "%d,%d", y, x);
    }
    strcpy(pairSet[pairSetSize++], pairStr);
}

int hasPair(int x, int y) {
    char pairStr[20];
    if (x < y) {
        sprintf(pairStr, "%d,%d", x, y);
    } else {
        sprintf(pairStr, "%d,%d", y, x);
    }
    for (int i = 0; i < pairSetSize; i++) {
        if (strcmp(pairSet[i], pairStr) == 0) return 1;
    }
    return 0;
}

void getAncestors(int nodeIdx, int parent[], int ancestors[], int *ancestorCount) {
    *ancestorCount = 0;
    int current = parent[nodeIdx];
    while (current != -1) {
        ancestors[(*ancestorCount)++] = current;
        current = parent[current];
    }
}

int canBeTreeWithRoot(int rootIdx) {
    int parent[1000];
    int children[1000][1000];
    int childrenCount[1000];
    
    for (int i = 0; i < nodeCount; i++) {
        parent[i] = -1;
        childrenCount[i] = 0;
    }
    
    parent[rootIdx] = -1;
    
    int remaining[1000];
    int remainingCount = 0;
    for (int i = 0; i < nodeCount; i++) {
        if (i != rootIdx) {
            remaining[remainingCount++] = i;
        }
    }
    
    int queue[1000];
    int queueStart = 0, queueEnd = 0;
    queue[queueEnd++] = rootIdx;
    
    while (queueStart < queueEnd && remainingCount > 0) {
        int current = queue[queueStart++];
        int nextChildren[1000];
        int nextChildrenCount = 0;
        
        for (int i = 0; i < remainingCount; i++) {
            int nodeIdx = remaining[i];
            int hasEdge = 0;
            for (int j = 0; j < adjCount[current]; j++) {
                if (adj[current][j] == nodeIdx) {
                    hasEdge = 1;
                    break;
                }
            }
            
            if (hasEdge) {
                int canBeChild = 1;
                
                int ancestors[1000];
                int ancestorCount;
                getAncestors(current, parent, ancestors, &ancestorCount);
                
                for (int k = 0; k < ancestorCount; k++) {
                    if (!hasPair(nodes[ancestors[k]], nodes[nodeIdx])) {
                        canBeChild = 0;
                        break;
                    }
                }
                
                if (canBeChild) {
                    nextChildren[nextChildrenCount++] = nodeIdx;
                }
            }
        }
        
        for (int i = 0; i < nextChildrenCount; i++) {
            int child = nextChildren[i];
            int found = -1;
            for (int j = 0; j < remainingCount; j++) {
                if (remaining[j] == child) {
                    found = j;
                    break;
                }
            }
            
            if (found != -1) {
                parent[child] = current;
                children[current][childrenCount[current]++] = child;
                queue[queueEnd++] = child;
                
                for (int j = found; j < remainingCount - 1; j++) {
                    remaining[j] = remaining[j + 1];
                }
                remainingCount--;
            }
        }
    }
    
    if (remainingCount > 0) {
        return 0;
    }
    
    char generatedPairs[10000][20];
    int generatedPairsSize = 0;
    
    for (int i = 0; i < nodeCount; i++) {
        int ancestors[1000];
        int ancestorCount;
        getAncestors(i, parent, ancestors, &ancestorCount);
        
        for (int j = 0; j < ancestorCount; j++) {
            char pairStr[20];
            int x = nodes[ancestors[j]], y = nodes[i];
            if (x < y) {
                sprintf(pairStr, "%d,%d", x, y);
            } else {
                sprintf(pairStr, "%d,%d", y, x);
            }
            
            int alreadyExists = 0;
            for (int k = 0; k < generatedPairsSize; k++) {
                if (strcmp(generatedPairs[k], pairStr) == 0) {
                    alreadyExists = 1;
                    break;
                }
            }
            
            if (!alreadyExists) {
                strcpy(generatedPairs[generatedPairsSize++], pairStr);
            }
        }
    }
    
    if (generatedPairsSize != pairSetSize) {
        return 0;
    }
    
    for (int i = 0; i < generatedPairsSize; i++) {
        int found = 0;
        for (int j = 0; j < pairSetSize; j++) {
            if (strcmp(generatedPairs[i], pairSet[j]) == 0) {
                found = 1;
                break;
            }
        }
        if (!found) {
            return 0;
        }
    }
    
    return 1;
}

int solution() {
    if (pairsSize == 0) {
        return 0;
    }
    
    nodeCount = 0;
    for (int i = 0; i < pairsSize; i++) {
        int found0 = 0, found1 = 0;
        for (int j = 0; j < nodeCount; j++) {
            if (nodes[j] == pairs[i][0]) found0 = 1;
            if (nodes[j] == pairs[i][1]) found1 = 1;
        }
        if (!found0) nodes[nodeCount++] = pairs[i][0];
        if (!found1) nodes[nodeCount++] = pairs[i][1];
    }
    
    qsort(nodes, nodeCount, sizeof(int), compareInt);
    int n = nodeCount;
    
    if (n == 1) {
        return 1;
    }
    
    for (int i = 0; i < nodeCount; i++) {
        adjCount[i] = 0;
    }
    pairSetSize = 0;
    
    for (int i = 0; i < pairsSize; i++) {
        int x = pairs[i][0], y = pairs[i][1];
        int xIdx = findNode(x), yIdx = findNode(y);
        
        adj[xIdx][adjCount[xIdx]++] = yIdx;
        adj[yIdx][adjCount[yIdx]++] = xIdx;
        addPair(x, y);
    }
    
    int visited[1000] = {0};
    int queue[1000];
    int queueStart = 0, queueEnd = 0;
    queue[queueEnd++] = 0;
    visited[0] = 1;
    
    while (queueStart < queueEnd) {
        int nodeIdx = queue[queueStart++];
        for (int i = 0; i < adjCount[nodeIdx]; i++) {
            int neighbor = adj[nodeIdx][i];
            if (!visited[neighbor]) {
                visited[neighbor] = 1;
                queue[queueEnd++] = neighbor;
            }
        }
    }
    
    int visitedCount = 0;
    for (int i = 0; i < n; i++) {
        if (visited[i]) visitedCount++;
    }
    
    if (visitedCount != n) {
        return 0;
    }
    
    int validRoots = 0;
    for (int i = 0; i < n; i++) {
        if (canBeTreeWithRoot(i)) {
            validRoots++;
            if (validRoots > 1) {
                return 2;
            }
        }
    }
    
    return validRoots >= 1 ? 1 : 0;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    pairsSize = 0;
    
    if (strstr(line, "[]")) {
        printf("%d\n", solution());
        return 0;
    }
    
    char *ptr = line;
    while (*ptr) {
        if (*ptr == '[' && *(ptr+1) != ']') {
            ptr++;
            char *end = ptr;
            while (*end && *end != ']') end++;
            if (*end == ']') {
                *end = '\0';
                char *comma = strchr(ptr, ',');
                if (comma) {
                    *comma = '\0';
                    int x = atoi(ptr);
                    int y = atoi(comma + 1);
                    pairs[pairsSize][0] = x;
                    pairs[pairsSize][1] = y;
                    pairsSize++;
                }
                ptr = end + 1;
            } else {
                ptr++;
            }
        } else {
            ptr++;
        }
    }
    
    int result = solution();
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × 2ⁿ)

Generate all possible tree structures (exponential) for each root choice

⚠ Quadratic Growth

Space Complexity

O(n²)

Store tree structures and validate ancestor relationships

⚠ Quadratic Space

12.0K Views

Medium Frequency

~35 min Avg. Time

245 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

Number Of Ways To Reconstruct A Tree - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Tree Generation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler