Binary Trees With Factors - Practice Coding Problems

Binary Trees With Factors - Problem

Imagine you're a tree architect with a unique challenge! You have an array of unique integers arr, where each number is greater than 1. Your task is to build special binary trees where:

Each non-leaf node's value equals the product of its two children's values
You can use each number from the array multiple times
All values in the tree must come from your given array

For example, with [2, 4, 5, 10]:

You can build a tree with root 10 and children 2 and 5 (since 2 × 5 = 10)
You can build a tree with root 4 and children both 2 (since 2 × 2 = 4)

Goal: Count how many different binary trees you can construct following these rules. Since the answer can be huge, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Python

$ Input: [2, 4]

› Output: 3

💡 Note: We can make these trees: [2], [4], and [4] with children [2, 2]. The root 4 has two children 2 and 2, and 2 × 2 = 4.

example_2.py — Python

$ Input: [2, 4, 5, 10]

› Output: 7

💡 Note: We can make trees: [2], [4], [5], [10], [4 with children 2,2], [10 with children 2,5], and [10 with children 5,2]. Note that [10 with children 2,5] and [10 with children 5,2] are different trees.

example_3.py — Python

$ Input: [3, 6]

› Output: 2

💡 Note: We can only make single-node trees [3] and [6]. We cannot make [6] with children [3,2] because 2 is not in our array.

Visualization

Tap to expand

Understanding the Visualization

Inventory Check

Sort available components [2,4,5,10] by size

Single Components

Each component can be a standalone product (4 ways)

Assembly Combinations

Find valid combinations: 4=2×2, 10=2×5, 10=5×2

Count Total Products

Sum all possible assembly configurations = 7 total

Key Takeaway

🎯 Key Insight: Use dynamic programming to avoid recalculating the same subtrees. For each number, the total trees equals 1 (single node) plus the sum of products of subtree counts for all valid factor pairs.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Sorting takes O(n log n), then for each of n elements, we check all previous elements for factor pairs

⚠ Quadratic Growth

Space Complexity

O(n)

DP array to store results for each element

⚡ Linearithmic Space

Constraints

1 ≤ arr.length ≤ 1000
2 ≤ arr[i] ≤ 10⁹
All values in arr are distinct
Answer is guaranteed to fit in a 32-bit signed integer after taking modulo 10⁹ + 7

Asked in

G Google 15 a Amazon 8 f Facebook 12 ⊞ Microsoft 6

The optimal approach uses dynamic programming with sorting. Sort the array and for each element, find all valid factor pairs from previously processed elements. The key insight is that dp[i] = 1 + Σ(dp[left] × dp[right]) for all valid factor pairs, achieving O(n²) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Sorting	O(n²)	O(n)	Sort array and build DP table bottom-up using factor pairs
Brute Force (Try All Combinations)	O(n³)	O(n)	Try every possible tree structure and check if it's valid

Dynamic Programming with Sorting — Algorithm Steps

Sort the array to process smaller numbers first
Create DP array where dp[i] = number of trees with arr[i] as root
For each element, find all factor pairs within processed elements
Calculate dp[i] = 1 + sum of (dp[left] × dp[right]) for all valid pairs
Return sum of all dp values

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort [2,4,5,10] to process in order

Process 2

dp[2] = 1 (single node)

Process 4

dp[4] = 1 + dp[2] × dp[2] = 2

Process 10

dp[10] = 1 + dp[2] × dp[5] + dp[5] × dp[2] = 3

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_SIZE 1000

typedef struct {
    int key;
    int value;
} IndexMap;

IndexMap index_map[MAX_SIZE];
int map_size = 0;
long long dp[MAX_SIZE];
int arr[MAX_SIZE];
int arr_size = 0;

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

int get_index(int key) {
    for (int i = 0; i < map_size; i++) {
        if (index_map[i].key == key) {
            return index_map[i].value;
        }
    }
    return -1;
}

void set_index(int key, int value) {
    index_map[map_size].key = key;
    index_map[map_size].value = value;
    map_size++;
}

int numFactoredBinaryTrees() {
    qsort(arr, arr_size, sizeof(int), compare);
    
    for (int i = 0; i < arr_size; i++) {
        set_index(arr[i], i);
    }
    
    for (int i = 0; i < arr_size; i++) {
        dp[i] = 1; // Single node tree
        
        for (int j = 0; j < i; j++) {
            if (arr[i] % arr[j] == 0) {
                int other = arr[i] / arr[j];
                int k = get_index(other);
                if (k != -1 && k <= i) {
                    dp[i] = (dp[i] + dp[j] * dp[k]) % MOD;
                }
            }
        }
    }
    
    long long result = 0;
    for (int i = 0; i < arr_size; i++) {
        result = (result + dp[i]) % MOD;
    }
    
    return (int)result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    char *token = strtok(line, "[,] \n");
    while (token != NULL) {
        arr[arr_size++] = atoi(token);
        token = strtok(NULL, "[,] \n");
    }
    
    printf("%d\n", numFactoredBinaryTrees());
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Sorting takes O(n log n), then for each of n elements, we check all previous elements for factor pairs

⚠ Quadratic Growth

Space Complexity

O(n)

DP array to store results for each element

⚡ Linearithmic Space

Constraints

1 ≤ arr.length ≤ 1000
2 ≤ arr[i] ≤ 10⁹
All values in arr are distinct
Answer is guaranteed to fit in a 32-bit signed integer after taking modulo 10⁹ + 7

73.9K Views

Medium Frequency

~22 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with Sorting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler