Why Partition Equal Subset Sum in DSA C++?

The Big Idea

What if you could instantly know if a group can be split perfectly in half without endless guessing?

The Scenario

Imagine you have a pile of coins with different values, and you want to split them into two piles with exactly the same total value. You try to do this by guessing and checking each possible way to divide them.

The Problem

Manually checking every possible way to split the coins is very slow and confusing. As the number of coins grows, the number of ways to try grows very fast, making it almost impossible to find the answer quickly or without mistakes.

The Solution

The Partition Equal Subset Sum method uses a smart way to check if such a split is possible without trying every combination. It uses a step-by-step approach to build up possible sums and quickly finds if the coins can be divided equally.

Before vs After

✗ Before

int total = 0;
for (int coin : coins) {
  total += coin;
}
// Try all subsets to find equal sum - very slow

✓ After

int total = 0;
for (int coin : coins) {
  total += coin;
}
if (total % 2 != 0) return false;
// Use dynamic programming to check subset sums efficiently

What It Enables

This concept enables fast and reliable checking if a set can be split into two equal parts, even when the set is large.

Real Life Example

Dividing tasks or resources evenly among two teams so that both have the same total workload or value without manually trying every possible division.

Key Takeaways

Manual checking of all subsets is too slow for many items.

Partition Equal Subset Sum uses dynamic programming to solve this efficiently.

It helps quickly decide if equal division is possible.

Practice

1. What does the Partition Equal Subset Sum problem ask you to determine about a given array of positive integers?

easy

A. If the array can be split into two subsets with equal sums

B. If the array contains any duplicate elements

C. If the array is sorted in ascending order

D. If the array contains only even numbers

Solution

1. Step 1: Understand the problem statement

   The problem asks whether the array can be divided into two parts where the sum of elements in both parts is the same.

2. Step 2: Identify the key condition

   This means the total sum of the array must be even, and there must be a subset with sum equal to half of the total sum.

3. Final Answer:

   If the array can be split into two subsets with equal sums -> Option A

4. Quick Check:

   Partition Equal Subset Sum = Split into equal sum subsets [OK]

Hint: Check if total sum is even to start [OK]

Common Mistakes:

• Thinking it checks for duplicates
• Assuming sorting is required
• Confusing with subset sum existence

2. Which of the following C++ code snippets correctly initializes a boolean DP array for the Partition Equal Subset Sum problem with size (sum/2 + 1) and sets the base case?

easy

A. bool dp[sum / 2 + 1]; std::fill(dp, dp + sum / 2 + 1, false); dp[0] = true;

B. std::vector<int> dp(sum / 2 + 1, 0); dp[0] = 1;

C. std::vector<bool> dp(sum / 2 + 1, false); dp[0] = true;

D. std::vector<bool> dp(sum + 1, false); dp[sum] = true;

Solution

1. Step 1: Choose correct data type and size

   We need a boolean vector of size (sum/2 + 1) to track subset sums. std::vector<bool> dp(sum / 2 + 1, false); dp[0] = true; uses correct size and type.

2. Step 2: Set base case correctly

   dp[0] = true means sum zero is always possible. std::vector<bool> dp(sum / 2 + 1, false); dp[0] = true; does this correctly. std::vector<int> dp(sum / 2 + 1, 0); dp[0] = 1; uses int vector, which is less appropriate. std::vector<bool> dp(sum + 1, false); dp[sum] = true; uses wrong size and sets dp[sum] instead of dp[0].

3. Final Answer:

   std::vector<bool> dp(sum / 2 + 1, false); dp[0] = true; -> Option C

4. Quick Check:

   Boolean vector with dp[0] true = Correct initialization [OK]

Hint: Use bool vector and set dp[0] = true for base case [OK]

Common Mistakes:

• Using int vector instead of bool
• Incorrect dp array size
• Setting wrong base case index

3. What is the output of the following C++ code snippet for the input array {1, 5, 11, 5}?

bool canPartition(std::vector<int>& nums) {
    int sum = 0;
    for (int num : nums) sum += num;
    if (sum % 2 != 0) return false;
    int target = sum / 2;
    std::vector<bool> dp(target + 1, false);
    dp[0] = true;
    for (int num : nums) {
        for (int j = target; j >= num; --j) {
            dp[j] = dp[j] || dp[j - num];
        }
    }
    return dp[target];
}

int main() {
    std::vector<int> nums = {1, 5, 11, 5};
    std::cout << (canPartition(nums) ? "true" : "false") << std::endl;
    return 0;
}

medium

A. true

B. false

C. Compilation error

D. Runtime error

Solution

1. Step 1: Calculate total sum and check parity

   Sum = 1 + 5 + 11 + 5 = 22, which is even, so proceed.

2. Step 2: Use DP to check subset sum of 11

   The code uses a boolean dp array to check if subset sum 11 is possible. The subsets {11} and {1,5,5} both sum to 11, so dp[11] becomes true.

3. Final Answer:

   true -> Option A

4. Quick Check:

   Subset sum 11 exists = true [OK]

Hint: Check if half sum subset exists using DP [OK]

Common Mistakes:

• Assuming sum odd means true
• Not iterating dp backwards
• Confusing output with subset elements

4. Identify the bug in the following code snippet for Partition Equal Subset Sum and select the fix:

bool canPartition(std::vector<int>& nums) {
    int sum = 0;
    for (int num : nums) sum += num;
    if (sum % 2 != 0) return false;
    int target = sum / 2;
    std::vector<bool> dp(target + 1, false);
    dp[0] = true;
    for (int num : nums) {
        for (int j = num; j <= target; ++j) {
            dp[j] = dp[j] || dp[j - num];
        }
    }
    return dp[target];
}

medium

A. Change sum check to if (sum % 2 == 0) return false

B. Initialize dp vector with true instead of false

C. Remove dp[0] = true assignment

D. Change inner loop to iterate backwards: for (int j = target; j >= num; --j)

Solution

1. Step 1: Analyze inner loop direction

   The inner loop iterates forwards, which causes dp to use updated values in the same iteration, leading to incorrect results.

2. Step 2: Correct loop direction

   Iterating backwards ensures dp[j - num] uses values from previous iteration, preserving correctness.

3. Final Answer:

   Change inner loop to iterate backwards: for (int j = target; j >= num; --j) -> Option D

4. Quick Check:

   Backward iteration in DP loop fixes state update [OK]

Hint: Iterate dp array backwards to avoid overwriting states [OK]

Common Mistakes:

• Iterating dp forwards causing wrong results
• Incorrect dp initialization
• Wrong sum parity check

5. Given the array {2, 2, 3, 5}, which of the following statements is true regarding the Partition Equal Subset Sum problem?

hard

A. The array can be partitioned into two subsets with equal sum: {2,3} and {2,5}

B. The array cannot be partitioned into two subsets with equal sum because no subset sums to half the total

C. The array can be partitioned into two subsets with equal sum: {2,2,3} and {5}

D. The array cannot be partitioned into two subsets with equal sum because total sum is odd

Solution

1. Step 1: Calculate total sum

   Sum = 2 + 2 + 3 + 5 = 12, which is even, so partition might be possible.

2. Step 2: Check for subset with sum 6

   Half sum = 6. Possible subsets: - {2,2,3} sum = 7 (too high) - {2,3} sum = 5 (too low) - {5} sum = 5 (too low) - {2,2} sum = 4 (too low) No subset sums exactly to 6.

3. Final Answer:

   The array cannot be partitioned into two subsets with equal sum because no subset sums to half the total -> Option B

4. Quick Check:

   Half sum subset missing = No partition [OK]

Hint: Check if half sum subset exists before concluding [OK]

Common Mistakes:

• Assuming total sum even means partition possible
• Incorrect subset sums calculation
• Confusing subsets with unequal sums