823. Binary Trees With Factors

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: `, , [4, 2, 2]````

Example 2:

```Input: arr = [2,4,5,10]
Output: 7
Explanation: We can make these trees: `, , , , [4, 2, 2], [10, 2, 5], [10, 5, 2]`.```

Constraints:

• `1 <= arr.length <= 1000`
• `2 <= arr[i] <= 109`

823. Binary Trees With Factors
``````struct Solution;
use std::collections::HashMap;

impl Solution {
fn num_factored_binary_trees(mut a: Vec<i32>) -> i32 {
let n = a.len();
let mut dp: Vec<i64> = vec![1; n];
let modulo = 1_000_000_007;
let mut hm: HashMap<i32, usize> = HashMap::new();
a.sort_unstable();
let mut res = 0;
for i in 0..n {
hm.insert(a[i], i);
for j in 0..i {
if a[i] % a[j] == 0 {
if let Some(&k) = hm.get(&(a[i] / a[j])) {
dp[i] += dp[j] * dp[k];
}
}
}
res = (res + dp[i]) % modulo;
}
res as i32
}
}

#[test]
fn test() {
let a = vec![2, 4];
let res = 3;
assert_eq!(Solution::num_factored_binary_trees(a), res);
let a = vec![2, 4, 5, 10];
let res = 7;
assert_eq!(Solution::num_factored_binary_trees(a), res);
}
``````