Partition Equal Subset Sum in DSA Java - 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 it's odd, partition is impossible. Otherwise, we try to find a subset with sum equal to half the total using dynamic programming.

Execution Sample

DSA Java

int sum = 0;
for (int num : nums) sum += num;
if (sum % 2 != 0) return false;
boolean[] dp = new boolean[sum / 2 + 1];
dp[0] = true;

Calculate total sum, check if odd, initialize DP array to track achievable sums.

Execution Table

Step	Operation	Current Number	DP Array State	Subset Sum Target	Result
1	Calculate total sum	-	-	-	sum = 11
2	Check if sum is odd	-	-	-	11 is odd, return false
Exit	No partition possible	-	-	-	Stop execution

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

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
sum	0	11	11	11
dp	null	null	null	null
target	undefined	undefined	undefined	undefined

Key Moments - 2 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 row 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 are achievable from subsets of the array. dp[i] is true if a subset sums to i. This is initialized after confirming sum is even, but in this example, we stop early due to odd sum.

Visual Quiz - 3 Questions

Look at the execution table, what is the sum after step 1?

A 12

B 10

C 11

D 0

💡 Hint

Check the 'Result' column in row with Step 1 in execution_table.

At which step do we decide the partition is impossible?

A Step 1

B Step 2

C Exit

D After DP initialization

💡 Hint

Look at the 'Operation' and 'Result' columns in execution_table row 2.

If the sum was even, what would be the next step after checking sum parity?

A Initialize dp array and set dp[0] = true

B Return false immediately

C Calculate sum again

D Return true immediately

💡 Hint

Refer to the execution_sample code and concept_flow after sum parity check.

Concept Snapshot

Partition Equal Subset Sum:
- Calculate total sum of array
- If sum is odd, return false
- Else, set target = sum/2
- Use DP to check if subset sums to target
- Return true if found, else false

Full Transcript

The Partition Equal Subset Sum problem checks if an array can be split into two subsets with equal sums. First, we add all numbers to get the total sum. If this 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. Then, we use a dynamic programming approach to find if any subset sums to this target. If yes, we return true; otherwise, false. In the example traced, the sum is 11, which is odd, so the function returns false without further processing.

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 array into two equal sum subsets [OK]

Hint: Check if total sum is even first to decide quickly [OK]

Common Mistakes:

• Thinking the problem is about sorting the array
• Confusing equal sum subsets with duplicate elements
• Ignoring the sum condition and just checking elements

2. Which of the following Java method signatures correctly represents a function to solve the Partition Equal Subset Sum problem?

easy

A. public boolean canPartition(int[] nums)

B. public int canPartition(int[] nums)

C. public void canPartition(int[] nums)

D. public String canPartition(int nums)

Solution

1. Step 1: Identify the return type

   The function should return true or false, so the return type must be boolean.

2. Step 2: Check parameter type

   The input is an array of integers, so parameter should be int[] nums.

3. Final Answer:

   public boolean canPartition(int[] nums) -> Option A

4. Quick Check:

   Boolean return + int array parameter = public boolean canPartition(int[] nums) [OK]

Hint: Return boolean for yes/no problems [OK]

Common Mistakes:

• Using int return type instead of boolean
• Using void return type which gives no answer
• Passing single int instead of int array

3. What will be the output of the following Java code snippet?

int[] nums = {1, 5, 11, 5};
System.out.println(canPartition(nums));

public static boolean canPartition(int[] nums) {
    int sum = 0;
    for (int num : nums) sum += num;
    if (sum % 2 != 0) return false;
    int target = sum / 2;
    boolean[] dp = new boolean[target + 1];
    dp[0] = true;
    for (int num : nums) {
        for (int i = target; i >= num; i--) {
            dp[i] = dp[i] || dp[i - num];
        }
    }
    return dp[target];
}

medium

A. Compilation error

B. false

C. true

D. Runtime exception

Solution

1. Step 1: Calculate total sum and check parity

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

2. Step 2: Use dynamic programming to check subset sum

   The dp array tracks sums achievable. The subset {11, 5, 5} sums to 21, but target is 11. Actually, subset {11} and {1,5,5} both sum to 11, so dp[target] becomes true.

3. Final Answer:

   true -> Option C

4. Quick Check:

   Subset sum equals half total sum = true [OK]

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

Common Mistakes:

• Not checking if total sum is even first
• Confusing dp array update direction
• Assuming subset must be contiguous

4. Identify the bug in this Java method for Partition Equal Subset Sum:

public boolean canPartition(int[] nums) {
    int sum = 0;
    for (int num : nums) sum += num;
    if (sum % 2 == 0) return false;
    int target = sum / 2;
    boolean[] dp = new boolean[target + 1];
    dp[0] = true;
    for (int num : nums) {
        for (int i = target; i >= num; i--) {
            dp[i] = dp[i] || dp[i - num];
        }
    }
    return dp[target];
}

medium

A. The dp array size is incorrect

B. The sum parity check condition is reversed

C. The inner loop should increment i instead of decrement

D. The method should return int instead of boolean

Solution

1. Step 1: Check sum parity condition

   The code returns false if sum % 2 == 0, but it should return false if sum is odd (sum % 2 != 0).

2. Step 2: Verify other parts

   dp array size and loops are correct; only the parity check is wrong.

3. Final Answer:

   The sum parity check condition is reversed -> Option B

4. Quick Check:

   Return false if sum is odd, not even [OK]

Hint: Remember: odd sum means no equal partition [OK]

Common Mistakes:

• Returning false when sum is even instead of odd
• Changing dp array size incorrectly
• Looping forward instead of backward causing wrong dp updates

5. Given the array nums = {2, 2, 3, 5}, which of the following modifications to the standard Partition Equal Subset Sum approach will correctly determine if the array can be partitioned into two subsets with equal sum, considering that elements can be used multiple times?

hard

A. Use a recursive approach without memoization

B. Keep the inner loop backward but initialize dp[1] = true

C. Double the target sum before processing

D. Change the inner loop to iterate from num to target (forward) instead of backward

Solution

1. Step 1: Understand the problem change

   Allowing elements multiple times means this is an unbounded subset sum problem, requiring forward iteration in dp update.

2. Step 2: Modify dp iteration accordingly

   Changing the inner loop to go from num to target (forward) allows reusing elements multiple times correctly.

3. Step 3: Verify other options

   Initializing dp[1] is incorrect; recursion without memo is inefficient; doubling target sum is wrong.

4. Final Answer:

   Change the inner loop to iterate from num to target (forward) instead of backward -> Option D

5. Quick Check:

   Unbounded subset sum needs forward dp loop [OK]

Hint: For repeated elements, loop forward in dp array [OK]

Common Mistakes:

• Using backward loop for repeated elements
• Incorrect dp initialization
• Ignoring efficiency by using recursion without memo