Codestin Search App

Target Sum - Problem

Target Sum is a classic dynamic programming problem that challenges you to find the number of ways to assign + and - signs to array elements to reach a target sum.

Given an integer array nums and an integer target, you need to build mathematical expressions by placing either a + or - sign before each number in the array. For example, with nums = [2, 1], you could create expressions like +2+1 = 3, +2-1 = 1, -2+1 = -1, or -2-1 = -3.

Your goal: Count how many different ways you can assign these signs to make the expression equal exactly target.

This problem beautifully combines backtracking, dynamic programming, and clever mathematical insights to transform what seems like an exponential problem into something much more manageable.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,1,1,1,1], target = 3

› Output: 5

💡 Note: There are 5 ways to assign symbols to make the sum 3: -1 + 1 + 1 + 1 + 1 = 3, +1 - 1 + 1 + 1 + 1 = 3, +1 + 1 - 1 + 1 + 1 = 3, +1 + 1 + 1 - 1 + 1 = 3, +1 + 1 + 1 + 1 - 1 = 3

example_2.py — Simple Case

$ Input: nums = [1], target = 1

› Output: 1

💡 Note: Only one way: assign + to the single element to get +1 = 1

example_3.py — Impossible Case

$ Input: nums = [1,2], target = 4

› Output: 0

💡 Note: Maximum possible sum is 1+2=3, minimum is -(1+2)=-3. Target 4 is impossible to achieve.

Constraints

1 ≤ nums.length ≤ 20
0 ≤ nums[i] ≤ 1000
0 ≤ sum(nums[i]) ≤ 1000
-1000 ≤ target ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Setup equations

If P = sum of positive numbers, N = sum of negative: P - N = target, P + N = total

Solve for P

Adding equations: 2P = total + target, so P = (total + target) / 2

Count subsets

Problem becomes: count subsets of nums that sum exactly to P

DP solution

Use classic subset sum DP: dp[i] = ways to make sum i

Key Takeaway

🎯 Key Insight: Transform the problem by recognizing that choosing which numbers to make positive is equivalent to finding subsets with a specific sum - this reduces exponential complexity to polynomial!

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 25 Apple 18

The optimal approach transforms this problem using the key insight that P - N = target and P + N = total, where P is the sum of positive numbers and N is the sum of negative numbers. This gives us P = (total + target) / 2, reducing the problem to counting subsets that sum to this value. Using 1D dynamic programming, we can solve it in O(n × sum) time and O(sum) space.

Common Approaches

Approach	Time	Space	Notes
✓ Subset Sum DP (Optimal)	O(n × sum)	O(sum)	Transform problem to counting subsets with specific sum using mathematical insight
Dynamic Programming with Memoization	O(n × sum_range)	O(n × sum_range)	Optimize backtracking by caching results for repeated subproblems

Subset Sum DP (Optimal) — Algorithm Steps

Calculate total sum of all numbers
Check if (total + target) is even and target is achievable
Transform problem: count subsets summing to (total + target) / 2
Use 1D DP array where dp[i] = ways to make sum i
For each number, update dp array from right to left

Visualization

Tap to expand

Step-by-Step Walkthrough

Mathematical insight

P - N = target, P + N = total → P = (total + target) / 2

Initialize DP

dp[0] = 1 (one way to make sum 0)

Process numbers

For each number, update dp array from right to left

Final answer

dp[target_sum] gives the count of valid subsets

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int findTargetSumWays(int* nums, int numsSize, int target) {
    int total = 0;
    for (int i = 0; i < numsSize; i++) {
        total += nums[i];
    }
    
    // Check if target is achievable
    if (target > total || target < -total || (total + target) % 2 == 1) {
        return 0;
    }
    
    // Transform to subset sum problem
    int subsetSum = (total + target) / 2;
    
    // DP array: dp[i] = ways to make sum i
    int* dp = (int*)calloc(subsetSum + 1, sizeof(int));
    dp[0] = 1; // One way to make sum 0: choose nothing
    
    // Process each number
    for (int i = 0; i < numsSize; i++) {
        // Update dp array from right to left to avoid double counting
        for (int j = subsetSum; j >= nums[i]; j--) {
            dp[j] += dp[j - nums[i]];
        }
    }
    
    int result = dp[subsetSum];
    free(dp);
    return result;
}

int main() {
    int nums[] = {1, 1, 1, 1, 1};
    int target = 3;
    printf("%d\n", findTargetSumWays(nums, 5, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × sum)

Where sum is (total + target) / 2. We process each number once and update dp array of size sum

✓ Linear Growth

Space Complexity

O(sum)

DP array of size (total + target) / 2 to store count of ways for each possible sum

✓ Linear Space

68.2K Views

High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Subset Sum DP (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler