Sure, here is a step-by-step solution in Python:

1. First, we need to check if the sum of all elements in the array is even. If it's not, we can immediately return False, because it's impossible to split the array into two subsets with equal sums.

```python
def canPartition(nums):
total_sum = sum(nums)
if total_sum % 2 != 0:
return False
```

2. If the total sum is even, we need to find a subset of numbers that adds up to total_sum / 2. We can do this using dynamic programming. We create a boolean array dp with length total_sum / 2 + 1, where dp[i] is True if there is a subset of nums that adds up to i.

```python
subset_sum = total_sum // 2
dp = [False] * (subset_sum + 1)
dp[0] = True
```

3. We iterate over each number in nums, and for each number, we iterate over the dp array backwards (from subset_sum to 0). If dp[i] is True and i + num

Question

Sure, here is a step-by-step solution in Python:

1. First, we need to check if the sum of all elements in the array is even. If it's not, we can immediately return False, because it's impossible to split the array into two subsets with equal sums.

```python
def canPartition(nums):
    total_sum = sum(nums)
    if total_sum % 2 != 0:
        return False
```

2. If the total sum is even, we need to find a subset of numbers that adds up to total_sum / 2. We can do this using dynamic programming. We create a boolean array dp with length total_sum / 2 + 1, where dp[i] is True if there is a subset of nums that adds up to i.

```python
    subset_sum = total_sum // 2
    dp = [False] * (subset_sum + 1)
    dp[0] = True
```

3. We iterate over each number in nums, and for each number, we iterate over the dp array backwards (from subset_sum to 0). If dp[i] is True and i + num <= subset_sum, we set dp[i + num] to True.

```python
    for num in nums:
        for i in range(subset_sum, -1, -1):
            if dp[i] and i + num <= subset_sum:
                dp[i + num] = True
```

4. Finally, we return dp[subset_sum]. If it's True, it means we can find a subset of nums that adds up to total_sum / 2, so we can split the array into two subsets with equal sums.

```python
    return dp[subset_sum]
```

Here is the complete function:

```python
def canPartition(nums):
    total_sum = sum(nums)
    if total_sum % 2 != 0:
        return False

subset_sum = total_sum // 2
    dp = [False] * (subset_sum + 1)
    dp[0] = True

for num in nums:
        for i in range(subset_sum, -1, -1):
            if dp[i] and i + num <= subset_sum:
                dp[i + num] = True

return dp[subset_sum]
```

Knowee AI · Accepted Answer