g0801_0900.s0823_binary_trees_with_factors.Solution Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation

Java-based LeetCode algorithm problem solutions, regularly updated

There is a newer version: 1.38

package g0801_0900.s0823_binary_trees_with_factors;

// #Medium #Array #Hash_Table #Dynamic_Programming
// #2022_03_23_Time_28_ms_(80.54%)_Space_42.6_MB_(79.87%)

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * 823 - Binary Trees With Factors\.
 *
 * Medium
 *
 * 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** 10⁹ + 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] <= 10⁹
 * *   All the values of `arr` are **unique**.
**/
public class Solution {
    private Map dp = new HashMap<>();
    private Map nums = new HashMap<>();
    private static final int MOD = (int) 1e9 + 7;

    public int numFactoredBinaryTrees(int[] arr) {
        Arrays.sort(arr);
        for (int i = 0; i < arr.length; i++) {
            nums.put(arr[i], i);
        }
        long ans = 0;
        for (int i = arr.length - 1; i >= 0; i--) {
            ans = (ans % MOD + recursion(arr, arr[i], i) % MOD) % MOD;
        }
        return (int) ans;
    }

    private long recursion(int[] arr, int v, int idx) {
        if (dp.containsKey(v)) {
            return dp.get(v);
        }
        long ret = 1;
        for (int i = 0; i < idx; i++) {
            int child = arr[i];
            if (v % child == 0 && nums.containsKey(v / child)) {
                ret +=
                        (recursion(arr, child, nums.get(arr[i]))
                                        % MOD
                                        * recursion(arr, v / child, nums.get(v / child))
                                        % MOD)
                                % MOD;
            }
        }
        dp.put(v, ret);
        return ret;
    }
}