Binary trees with factors

Array Hash Table Dynamic Programming Sorting

53.1% acceptance

Feb 22, 2026

3369

262

Given an array of unique integers, arr, where each integer arr[i] is strictly greater than 1. We make a binary tree using these integers, and each number may be used for any number of times. Each non-leaf node's value should be equal to the product of the values of its children. Return the number of binary trees we can make. The answer may be too large so return the answer modulo 109 + 7.

Solution

Rust

Time O(n²)

Space O(n)

LeetCode

solution.rs

/*
 * Given an array of unique integers, arr, where each integer arr[i] is strictly greater than 1.
 * We make a binary tree using these integers, and each number may be used for any number of times. Each non-leaf node's value should be equal to the product of the values of its children.
 * Return the number of binary trees we can make. The answer may be too large so return the answer modulo 109 + 7.
 * Example 1:
 * Input: arr = [2,4]
 * Output: 3
 * Explanation: We can make these trees: [2], [4], [4, 2, 2]
 * Example 2:
 * Input: arr = [2,4,5,10]
 * Output: 7
 * Explanation: We can make these trees: [2], [4], [5], [10], [4, 2, 2], [10, 2, 5], [10, 5, 2].
 * Constraints:
 * 1 <= arr.length <= 1000
 * 2 <= arr[i] <= 109
 * All the values of arr are unique.
 */

use std::collections::HashMap;
impl Solution {
  pub fn num_factored_binary_trees(mut arr: Vec<i32>) -> i32 {
    const MOD: i64 = 1_000_000_007;
    arr.sort();
    let mut dp: HashMap<i64, i64> = HashMap::new();
    for (i, &v) in arr.iter().enumerate() {
      let v = v as i64;
      let mut cnt: i64 = 1;
      for j in 0..i {
        let a = arr[j] as i64;
        if v % a == 0 {
          let b = v / a;
          if let Some(&db) = dp.get(&b) {
            cnt = (cnt + dp[&a] * db) % MOD;
          }
        }
      }
      dp.insert(v, cnt);
    }
    (dp.values().sum::<i64>() % MOD) as i32
  }
}