Number of Ways to Reorder Array to Get Same BST

Number of Ways to Reorder Array to Get Same BST - Problem

Array Math Divide and Conquer Dynamic Programming Tree Union Find Binary Search Tree Memoization Combinatorics Binary Tree Hard

Imagine you're given an array nums representing a permutation of integers from 1 to n. Your task is to construct a Binary Search Tree (BST) by inserting elements from the array in order into an initially empty tree. The fascinating challenge is to determine how many different ways you can reorder this array while still producing the exact same BST structure.

For example, with [2,1,3]: we get root=2, left child=1, right child=3. The array [2,3,1] creates the identical BST, but [3,2,1] produces a completely different tree structure.

Goal: Count all possible reorderings that yield the same BST as the original array. Since this number can be astronomically large, return the result modulo 10⁹ + 7.

Input & Output

example_1.py — Python

$ Input: [2,1,3]

› Output: 2

💡 Note: Arrays [2,1,3] and [2,3,1] both create BST with root=2, left child=1, right child=3. Other permutations like [1,2,3] create different BST structures.

example_2.py — Python

$ Input: [3,4,5,1,2]

› Output: 5

💡 Note: Root=3 splits into left=[1,2] and right=[4,5]. Left subtree has 1 arrangement, right has 1 arrangement, and we can interleave them in C(4,2)=6 ways, but we must subtract 1 from final result: (1×1×6)-1=5.

example_3.py — Python

$ Input: [1,2,3]

› Output: 1

💡 Note: This creates a completely right-skewed BST. Only one arrangement preserves this structure since each node has exactly one possible position.

Constraints

1 ≤ nums.length ≤ 1000
nums is a permutation of integers from 1 to n
All elements in nums are distinct
Answer should be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Root Determines Structure

First element becomes root and partitions remaining elements

Recursive Partitioning

Elements < root go left, elements > root go right

Count Subtree Arrangements

Recursively count valid arrangements for each subtree

Combinatorial Interleaving

Use C(n,k) to count ways to merge left and right sequences

Key Takeaway

🎯 Key Insight: BST structure constraints allow us to use combinatorics instead of generating all permutations, reducing complexity from O(n!) to O(n²)

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal solution uses dynamic programming with combinatorics to efficiently count BST arrangements. Key insight: for any subtree, we can interleave left and right elements in C(left+right, left) ways while preserving BST structure. Time complexity: O(n²), Space: O(n²).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Permutations)	O(n! × n)	O(n! + n)	Generate all possible permutations and check which ones create the same BST
Dynamic Programming with Combinatorics (Optimal)	O(n²)	O(n²)	Use recursive DP with combinatorics to count valid arrangements efficiently

Brute Force (Generate All Permutations) — Algorithm Steps

Generate all n! permutations of the input array
For each permutation, build a BST by inserting elements in order
Compare each resulting BST with the original BST structure
Count permutations that produce identical BST structures
Return count modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Array

Start with [2,1,3] and build original BST

Generate Permutations

Create all 6 permutations: [2,1,3], [2,3,1], [1,2,3], etc.

Build BST for Each

Construct BST for each permutation

Compare Structures

Count permutations that create identical BST structure

Code -

solution.c — C

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

#define MOD 1000000007

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

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

struct TreeNode* buildBst(int* arr, int size) {
    if (size == 0) return NULL;
    
    int root = arr[0];
    int* left = (int*)malloc(size * sizeof(int));
    int* right = (int*)malloc(size * sizeof(int));
    int leftSize = 0, rightSize = 0;
    
    for (int i = 1; i < size; i++) {
        if (arr[i] < root) {
            left[leftSize++] = arr[i];
        } else {
            right[rightSize++] = arr[i];
        }
    }
    
    struct TreeNode* node = createNode(root);
    node->left = buildBst(left, leftSize);
    node->right = buildBst(right, rightSize);
    
    free(left);
    free(right);
    return node;
}

bool treesEqual(struct TreeNode* t1, struct TreeNode* t2) {
    if (!t1 && !t2) return true;
    if (!t1 || !t2) return false;
    return t1->val == t2->val && 
           treesEqual(t1->left, t2->left) && 
           treesEqual(t1->right, t2->right);
}

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

bool nextPermutation(int* nums, int size) {
    int i = size - 2;
    while (i >= 0 && nums[i] >= nums[i + 1]) {
        i--;
    }
    
    if (i < 0) return false;
    
    int j = size - 1;
    while (nums[j] <= nums[i]) {
        j--;
    }
    
    swap(&nums[i], &nums[j]);
    
    int left = i + 1, right = size - 1;
    while (left < right) {
        swap(&nums[left], &nums[right]);
        left++;
        right--;
    }
    
    return true;
}

int numOfWays(int* nums, int numsSize) {
    if (numsSize <= 1) return 1;
    
    int* original = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        original[i] = nums[i];
    }
    
    struct TreeNode* originalBst = buildBst(original, numsSize);
    
    // Sort nums for permutation generation
    for (int i = 0; i < numsSize - 1; i++) {
        for (int j = 0; j < numsSize - i - 1; j++) {
            if (nums[j] > nums[j + 1]) {
                swap(&nums[j], &nums[j + 1]);
            }
        }
    }
    
    int count = 0;
    
    do {
        int* perm = (int*)malloc(numsSize * sizeof(int));
        for (int i = 0; i < numsSize; i++) {
            perm[i] = nums[i];
        }
        
        if (treesEqual(buildBst(perm, numsSize), originalBst)) {
            count = (count + 1) % MOD;
        }
        
        free(perm);
    } while (nextPermutation(nums, numsSize));
    
    free(original);
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each taking O(n) time to build BST and compare

⚠ Quadratic Growth

Space Complexity

O(n! + n)

O(n!) to store permutations, O(n) for BST construction and recursion stack

⚠ Quadratic Space

18.9K Views

Medium Frequency

~25 min Avg. Time

542 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