Partition Array into Two Equal Product Subsets

Partition Array into Two Equal Product Subsets - Problem

Given an integer array nums containing distinct positive integers and an integer target, your task is to determine if you can split the array into two non-empty disjoint subsets such that:

Each element belongs to exactly one subset
The product of elements in each subset equals target

Return true if such a partition exists, false otherwise.

Example: If nums = [2, 3, 4, 6] and target = 12, we can partition into {2, 6} and {3, 4} since 2 × 6 = 12 and 3 × 4 = 12.

Input & Output

example_1.py — Basic Valid Partition

$ Input: nums = [2, 3, 4, 6], target = 12

› Output: true

💡 Note: We can partition into {2, 6} and {3, 4}. Both subsets have product 12 (2×6=12, 3×4=12)

example_2.py — No Valid Partition

$ Input: nums = [1, 2, 3, 4], target = 5

› Output: false

💡 Note: No way to partition the array such that both subsets have product 5. Total product is 24, but we need each subset to have product 5

example_3.py — Perfect Squares

$ Input: nums = [1, 4, 9], target = 6

› Output: false

💡 Note: Total product is 36. For equal products of 6 each, we'd need total product to be 36, but no valid partition exists

Visualization

Tap to expand

Understanding the Visualization

Count Total Treasure

Calculate the product of all coin values to verify if equal division is mathematically possible

Try All Divisions

Systematically try every way to split coins between two chests

Check Balance

For each division, multiply coin values in each chest and check if both equal the target

Success or Failure

Return success when a valid division is found, or failure if no division works

Key Takeaway

🎯 Key Insight: For equal partition with product = target, total array product must equal target²

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate all 2^n possible subsets and check each one

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack or iterative subset generation

⚡ Linearithmic Space

Constraints

2 ≤ nums.length ≤ 20
1 ≤ nums[i] ≤ 10⁶
1 ≤ target ≤ 10¹²
All elements in nums are distinct
All elements are positive integers

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

This problem requires partitioning an array into two subsets with equal products. The brute force approach generates all possible subsets using bit manipulation and checks if any partition satisfies the condition. With constraints limiting array size to 20, the O(2^n) complexity is acceptable. Key insight: if both subsets have product = target, then total array product = target².

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subsets)	O(2^n)	O(n)	Generate all possible subsets and check if any pair has both products equal to target

Brute Force (Generate All Subsets) — Algorithm Steps

Generate all possible subsets using bit manipulation or recursion
For each subset, calculate the product of its elements
Calculate the product of remaining elements (complement subset)
Check if both products equal the target value
Return true if such a partition is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Use bit manipulation to generate all 2^n subsets

Calculate Products

For each subset, calculate product of elements in both subsets

Check Target

Verify if both subset products equal the target value

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>

bool canPartition(int* nums, int numsSize, int target) {
    // Try all possible subsets using bit manipulation
    for (int mask = 1; mask < (1 << numsSize) - 1; mask++) {
        long long subset1Product = 1;
        long long subset2Product = 1;
        
        for (int i = 0; i < numsSize; i++) {
            if (mask & (1 << i)) {
                subset1Product *= nums[i];
            } else {
                subset2Product *= nums[i];
            }
        }
        
        if (subset1Product == target && subset2Product == target) {
            return true;
        }
    }
    
    return false;
}

int main() {
    int nums[] = {2, 3, 4, 6};
    int target = 12;
    printf("%s\n", canPartition(nums, 4, target) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate all 2^n possible subsets and check each one

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack or iterative subset generation

⚡ Linearithmic Space

Constraints

2 ≤ nums.length ≤ 20
1 ≤ nums[i] ≤ 10⁶
1 ≤ target ≤ 10¹²
All elements in nums are distinct
All elements are positive integers

23.0K Views

Medium Frequency

~25 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate All Subsets) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler