solution(java): 823. Binary Trees With Factors

823. Binary Trees With Factors
- Java

Medium/823. Binary Trees With Factors/README.md

@@ -0,0 +1,26 @@
+<h3>823. Binary Trees With Factors</h3><br>
+<strong>Medium</strong><br><br>
+
+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.
+<br>
+
+Example 1:<br>
+Input: arr = [2,4]<br>
+Output: 3<br>
+Explanation: We can make these trees: [2], [4], [4, 2, 2]
+<br>
+
+Example 2:<br>
+Input: arr = [2,4,5,10<br>
+Output: 7<br>
+Explanation: We can make these trees: [2], [4], [5], [10], [4, 2, 2], [10, 2, 5], [10, 5, 2].
+<br>
+
+Constraints:<br>
+1. <= arr.length <= 1000<br>
+2. <= arr[i] <= 109<br>
+All the values of arr are unique.

Medium/823. Binary Trees With Factors/Solution.java

@@ -0,0 +1,32 @@
+public class Solution {
+	// Method to count the number of binary trees that can be formed
+	public int numFactoredBinaryTrees(int[] arr) {
+		// Sort the array
+	        Arrays.sort(arr);
+	        // Create a map to store the count of subtrees for each element
+	        Map<Integer, Long> subtreeCount = new HashMap<>();
+	        for (int root : arr) {
+	            subtreeCount.put(root, 1L);
+	            for (int factor : arr) {
+	                if (factor >= root) {
+	                    break;
+	                }
+
+	                /* Check if the current factor is a factor of the root 
+	                 * and if the root/factor is present in the map */
+	                if (root % factor == 0 && subtreeCount.containsKey(root / factor)) {
+	                	// Update the subtree count for the current root
+	                    subtreeCount.put(root, 
+	                    		(subtreeCount.get(root) + subtreeCount.get(factor) * subtreeCount.get(root / factor)));
+	                }
+	            }
+	        }
+
+	        long totalTrees = 0L;
+	        for (int key : subtreeCount.keySet()) {
+	            totalTrees = (totalTrees + subtreeCount.get(key)) % 1_000_000_007;
+	        }
+
+		return (int) totalTrees;       
+	}
+}