Partition Equal Subset Sum in DSA C# - Time & Space Complexity

Time Complexity: Partition Equal Subset Sum

O(n * sum)

Understanding Time Complexity

We want to know how the time needed to check if an array can be split into two equal sum parts grows as the array size grows.

How does the algorithm's work increase when the input numbers or their sum get bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

public bool CanPartition(int[] nums) {
    int total = 0;
    foreach (int num in nums) total += num;
    if (total % 2 != 0) return false;
    int target = total / 2;
    bool[] dp = new bool[target + 1];
    dp[0] = true;
    foreach (int num in 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 parts with equal sums using a dynamic programming approach.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Nested loops where the outer loop goes through each number and the inner loop goes through possible sums up to target.
• How many times: Outer loop runs n times (n = number of elements), inner loop runs up to target sum times.

How Execution Grows With Input

The time grows with both the number of elements and the half of the total sum of elements.

Input Size (n)	Approx. Operations (target sum)
10 elements, sum 40 (target 20)	10 * 20 = 200
100 elements, sum 400 (target 200)	100 * 200 = 20,000
1000 elements, sum 4000 (target 2000)	1000 * 2000 = 2,000,000

Pattern observation: The operations grow roughly by multiplying the number of elements by the target sum, so doubling either doubles the work.

Final Time Complexity

Time Complexity: O(n * sum)

This means the time needed grows with both the number of elements and the total sum of the array.

Common Mistake

[X] Wrong: "The time depends only on the number of elements, so it is O(n)."

[OK] Correct: The time also depends on the sum of the elements because the algorithm checks sums up to half the total sum, not just the count of numbers.

Interview Connect

Understanding this time complexity helps you explain how dynamic programming handles problems involving sums and subsets, a common pattern in interviews.

Self-Check

"What if we used recursion with memoization instead of this bottom-up approach? How would the time complexity change?"

Practice

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

easy

A. If the array is sorted in ascending order

B. If the array contains any duplicate elements

C. If the array contains only positive numbers

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

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: Clarify what is being checked

   It is not about duplicates, sorting, or positivity, but about equal sum partitioning.

3. Final Answer:

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

4. Quick Check:

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

Hint: Focus on splitting array into two equal sum parts [OK]

Common Mistakes:

• Confusing with checking duplicates
• Thinking about sorting order
• Assuming all numbers must be positive

2. Which of the following C# code snippets correctly initializes a boolean array named dp of size sum + 1 for the Partition Equal Subset Sum problem?

easy

A. bool[] dp = new bool[sum];

B. bool[] dp = new bool(sum + 1);

C. bool[] dp = new bool[sum + 1];

D. bool dp = new bool[sum + 1];

Solution

1. Step 1: Understand array initialization syntax in C#

   Arrays are initialized with square brackets and the size inside new[]. For size sum+1, use new bool[sum + 1].

2. Step 2: Check each option

   bool[] dp = new bool[sum]; misses +1, bool dp = new bool[sum + 1]; uses wrong type declaration, bool[] dp = new bool(sum + 1); uses parentheses which is invalid.

3. Final Answer:

   bool[] dp = new bool[sum + 1]; -> Option C

4. Quick Check:

   Correct C# array syntax = bool[] dp = new bool[sum + 1]; [OK]

Hint: Use square brackets and new keyword for arrays in C# [OK]

Common Mistakes:

• Forgetting +1 for array size
• Using parentheses instead of square brackets
• Declaring array as single bool variable

3. What will be the output of the following C# code snippet for the input array nums = new int[] {1, 5, 11, 5};?

bool CanPartition(int[] nums) {
    int sum = 0;
    foreach (int num in nums) sum += num;
    if (sum % 2 != 0) return false;
    int target = sum / 2;
    bool[] dp = new bool[target + 1];
    dp[0] = true;
    foreach (int num in nums) {
        for (int i = target; i >= num; i--) {
            dp[i] = dp[i] || dp[i - num];
        }
    }
    return dp[target];
}

Console.WriteLine(CanPartition(nums));

medium

A. true

B. false

C. Compile-time error

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

   Target = 11. The dp array tracks if sum i is achievable. The code finds that subset {11} or {5,5,1} sums to 11, so dp[11] = true.

3. Final Answer:

   true -> Option A

4. Quick Check:

   Sum even and subset sum found = true [OK]

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

Common Mistakes:

• Not checking if sum is even
• Incorrect dp array update direction
• Returning false prematurely

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

bool CanPartition(int[] nums) {
    int sum = 0;
    foreach (int num in nums) sum += num;
    if (sum % 2 != 0) return false;
    int target = sum / 2;
    bool[] dp = new bool[target];
    dp[0] = true;
    foreach (int num in nums) {
        for (int i = target; i >= num; i--) {
            dp[i] = dp[i] || dp[i - num];
        }
    }
    return dp[target];
}

medium

A. Initialize dp array with false values explicitly

B. Change dp array size to target + 1

C. Change loop to iterate from 0 to target

D. Remove the dp[0] = true assignment

Solution

1. Step 1: Check dp array size and indexing

   dp array is declared with size target, but dp[target] is accessed, causing out-of-range error.

2. Step 2: Fix array size to include target index

   Change dp size to target + 1 to safely access dp[target].

3. Final Answer:

   Change dp array size to target + 1 -> Option B

4. Quick Check:

   Array size must cover all indices used [OK]

Hint: Array size must be one more than max index accessed [OK]

Common Mistakes:

• Ignoring array index out of range
• Changing loop direction unnecessarily
• Removing dp[0] initialization

5. Given the array nums = new int[] {2, 2, 3, 5}, which of the following statements is true regarding the Partition Equal Subset Sum problem?

hard

A. The array cannot be partitioned into two subsets with equal sum

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

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

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

Solution

1. Step 1: Calculate total sum of array elements

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

2. Step 2: Check possible subsets for half sum (6)

   Half sum = 6. Possible subsets: {2,2,2} no (only two 2s), {3,3} no (only one 3), {5,1} no 1 missing. No subset sums to 6 exactly.

3. Step 3: Verify given options

   The array can be partitioned into two subsets with equal sum: {2,3} and {2,5} sums: {2,3}=5 and {2,5}=7 (not equal). The array can be partitioned into two subsets with equal sum: {2,2,3} and {5} sums: {2,2,3}=7 and {5}=5 (not equal). The array can be partitioned into two subsets with equal sum: {3,5} and {2,2} sums: {3,5}=8 and {2,2}=4 (not equal).

4. Final Answer:

   The array cannot be partitioned into two subsets with equal sum -> Option A

5. Quick Check:

   Sum even but no subset sums to half sum = false [OK]

Hint: Check if any subset sums exactly to half total sum [OK]

Common Mistakes:

• Assuming even sum means partition always possible
• Incorrectly summing subsets
• Ignoring subset element counts