Codestin Search App

Count Ways to Build Rooms in an Ant Colony - Problem

Math Dynamic Programming Tree Graph Topological Sort Combinatorics Hard

Count Ways to Build Rooms in an Ant Colony

You are an industrious ant architect tasked with expanding your colony by adding n new rooms numbered 0 to n-1. The construction must follow a specific expansion plan represented as an array prevRoom, where prevRoom[i] indicates that room prevRoom[i] must be built before room i, and these rooms must be directly connected.

Room 0 is already built (so prevRoom[0] = -1), and the plan ensures all rooms will eventually be reachable from room 0. The challenge: You can only build one room at a time, and you can only build a room if its prerequisite room already exists.

Your mission: Calculate how many different orders you can build all the rooms in. Since the number can be astronomically large, return the answer modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Tree

$ Input: prevRoom = [-1, 0, 1]

› Output: 1

💡 Note: Tree: 0 → 1 → 2. Only one valid order: build room 1 first, then room 2. Total ways = 1.

example_2.py — Tree with Multiple Children

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

› Output: 6

💡 Note: Tree: 0 has children [1,2]; 1 has child [3]; 2 has child [4]. Valid orders include [1,3,2,4], [1,2,3,4], [1,2,4,3], [2,4,1,3], [2,1,3,4], [2,1,4,3]. Total ways = 6.

example_3.py — Single Chain

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

› Output: 1

💡 Note: Linear chain: 0 → 1 → 2 → 3. Only one valid order possible: [1,2,3]. Total ways = 1.

Constraints

n == prevRoom.length
2 ≤ n ≤ 10⁵
prevRoom[0] == -1
0 ≤ prevRoom[i] ≤ n - 1 for i ≠ 0
prevRoom represents a valid tree

Visualization

Tap to expand

Understanding the Visualization

Parse Tree Structure

Convert the prevRoom array into a tree where each node knows its children

Calculate Subtree Sizes

Use DFS to find how many nodes are in each subtree

Apply Combinatorics

For each node with multiple children, calculate how many ways to interleave their construction orders

Combine Results

Multiply the arrangements from each subtree to get the final answer

Key Takeaway

🎯 Key Insight: By modeling the problem as a tree and using multinomial coefficients, we can count valid orderings in O(n) time without generating them explicitly.

Asked in

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

The optimal solution uses tree dynamic programming with combinatorics. By recognizing that prevRoom forms a tree structure, we can calculate the number of valid building orders using multinomial coefficients. For each node, we count arrangements in its subtree and combine them using the formula: total_arrangements = subtree_size! / (child1_size! × child2_size! × ...). This achieves O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Permutations)	O(n! × n)	O(n)	Generate all possible building orders and count valid ones
Tree DP with Combinatorics (Optimal)	O(n)	O(n)	Use tree structure and multinomial coefficients to count valid orderings efficiently

Brute Force (Generate All Permutations) — Algorithm Steps

Generate all possible permutations of rooms 1 to n-1 (room 0 is always first)
For each permutation, check if prerequisites are satisfied
Count valid permutations
Return count modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutation

Create a possible building order

Validate Order

Check if prerequisites are satisfied

Count Valid

Increment counter if order is valid

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define MOD 1000000007

int countValid(int* remaining, int remainingSize, int* prevRoom, bool* built, int n) {
    if (remainingSize == 0) return 1;
    
    int count = 0;
    for (int i = 0; i < remainingSize; i++) {
        int room = remaining[i];
        if (built[prevRoom[room]]) {
            int* newRemaining = (int*)malloc((remainingSize - 1) * sizeof(int));
            int idx = 0;
            for (int j = 0; j < remainingSize; j++) {
                if (j != i) newRemaining[idx++] = remaining[j];
            }
            
            built[room] = true;
            count = (count + countValid(newRemaining, remainingSize - 1, prevRoom, built, n)) % MOD;
            built[room] = false;
            
            free(newRemaining);
        }
    }
    return count;
}

int waysToBuildRooms(int* prevRoom, int prevRoomSize) {
    int n = prevRoomSize;
    int* rooms = (int*)malloc((n - 1) * sizeof(int));
    bool* built = (bool*)calloc(n, sizeof(bool));
    
    for (int i = 1; i < n; i++) {
        rooms[i - 1] = i;
    }
    built[0] = true;
    
    int result = countValid(rooms, n - 1, prevRoom, built, n);
    
    free(rooms);
    free(built);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

Generate n! permutations, each taking O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and current permutation

⚡ Linearithmic Space

67.2K Views

Medium Frequency

~35 min Avg. Time

1.8K 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 (Generate All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler