Partition Equal Subset Sum in DSA C++ - Execution Trace

Concept Flow - Partition Equal Subset Sum

Calculate total sum of array

↓

Check if sum is odd?

Yes→Return False: cannot partition

No↓

Set target = sum/2

↓

Use DP to check if subset sums to target

↓

If subset found

→Return True

No↓

Return False

We first find the total sum. If odd, partition is impossible. Otherwise, we check if a subset sums to half the total using dynamic programming.

Execution Sample

DSA C++

bool canPartition(vector<int>& nums) {
  int sum = 0;
  for (int n : nums) sum += n;
  if (sum % 2 != 0) return false;
  int target = sum / 2;
  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];
}

This code checks if the array can be split into two subsets with equal sum by using a boolean DP array to track achievable sums.

Execution Table

Step	Operation	Current Number	DP Array State (index:true/false)	Action
1	Calculate total sum	-	-	Sum = 11
2	Check if sum is odd	-	-	11 is odd, cannot partition
3	Return result	-	-	False returned

💡 Sum is odd (11), so partition into equal subsets is impossible.

Variable Tracker

Variable	Start	After sum calc	After check	Final
sum	0	11	11	11
target	-	-	-	-
dp	-	-	-	-

Key Moments - 3 Insights

Why do we return false immediately when the sum is odd?

Because an odd total sum cannot be split into two equal integer parts. This is shown in execution_table step 2 where sum=11 is odd, so partition is impossible.

What does the dp array represent in this problem?

The dp array tracks which sums can be formed from subsets of the numbers. dp[j] is true if a subset sums to j. This is the core of the dynamic programming approach.

Why do we iterate backwards in the inner loop when updating dp?

Iterating backwards prevents using the same number multiple times in one iteration, ensuring each number is only counted once per subset sum calculation.

Visual Quiz - 3 Questions

Look at the execution_table, what is the result when sum is 11?

A True, partition possible

B False, partition impossible

C Need more computation

D Error in code

💡 Hint

Refer to execution_table row 2 where sum=11 is odd, so partition is impossible.

If the input array was [1,5,11,5], what would be the target sum?

A 10

B 22

C 11

D None of the above

💡 Hint

Sum is 1+5+11+5=22, target is sum/2 = 11, see concept_flow step 'Set target = sum/2'.

Why does the dp array start with dp[0] = true?

A Because sum zero is always achievable with empty subset

B Because zero is the target sum

C To mark all sums as achievable initially

D To indicate no numbers processed yet

💡 Hint

Refer to execution_sample code line 'dp[0] = true;' meaning empty subset sums to zero.

Concept Snapshot

Partition Equal Subset Sum:
- Find total sum of array
- If sum is odd, return false
- Else, target = sum/2
- Use DP boolean array dp to track achievable sums
- dp[0] = true (empty subset)
- For each num, update dp backwards
- Return dp[target] as result

Full Transcript

The Partition Equal Subset Sum problem checks if an array can be split into two subsets with equal sums. First, we calculate the total sum. If the sum is odd, it's impossible to split equally, so we return false immediately. If the sum is even, we set a target as half the sum. We then use a dynamic programming approach with a boolean array dp, where dp[j] indicates if a subset sum j is achievable. We initialize dp[0] as true because an empty subset sums to zero. For each number in the array, we update dp backwards to avoid counting the same number multiple times. Finally, we return dp[target], which tells us if a subset with sum equal to half the total exists, meaning the array can be partitioned equally.

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