823. Binary Trees With Factors

Problem Statement

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.

Intuition

Approach:

eg 
2 4 5 20
1 1 1 1

Each at start have one way to make a tree,
But we find extra ways to find trees in the system,

like 
for 20 -> 4,5
Number of occurences of 4,5 is 1 so 1*1 extra ways
so on we upadte extra ways for 20

Links

https://leetcode.com/problems/binary-trees-with-factors/?envType=daily-question&envId=2023-10-26

Video Links

https://www.youtube.com/watch?v=BRGz8ArRiPA&ab_channel=CodewithAlisha

Approach 1:

C++

class Solution {
public:
    int numFactoredBinaryTrees(vector<int>& arr) {
        int n= arr.size();
        sort(arr.begin(), arr.end());
        unordered_map<int,long long int> mp;

        for(auto &it: arr)
            mp[it]++;

        for(int i=0; i<n; i++){
            long long int count=0;
            for(int j=0; j<i; j++){
                if(arr[i]%arr[j] == 0){
                    int num = arr[i]/arr[j];
                    if(mp.find(num) != mp.end()){
                        count += mp[arr[j]] * mp[num];
                    }
                }
            }
            mp[arr[i]] += count;
        }

        long long int ans=0;
        for(auto &it: mp){
            ans += it.second;
        }

        return ans % int(1e9+7);
    }
};

Approach 2:

C++

Approach 3:

C++

Approach 4:

C++