Combination Sum IV - Practice Coding Problems

Combination Sum IV - Problem

Imagine you're a cashier with an unlimited supply of different coin denominations, and you need to find out how many different ways you can make change for a specific amount. This is exactly what the Combination Sum IV problem asks!

Given an array of distinct positive integers nums and a target integer target, return the number of possible combinations that add up to the target. Unlike traditional combination problems, order matters here - so [1,2] and [2,1] are considered different combinations.

Example: If nums = [1,2,3] and target = 4, the valid combinations are: [1,1,1,1], [1,1,2], [1,2,1], [2,1,1], [2,2], [1,3], [3,1] - that's 7 different ways!

The challenge is to count all these combinations efficiently without actually generating them, as the number can be very large.

Input & Output

example_1.py — Basic case

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

› Output: 7

💡 Note: The possible combinations are: [1,1,1,1], [1,1,2], [1,2,1], [2,1,1], [2,2], [1,3], [3,1]. Note that different sequences are counted as different combinations.

example_2.py — Single element

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

› Output: 0

💡 Note: Since 9 > 3, there's no way to make sum 3 using only 9s, so the answer is 0.

example_3.py — Edge case

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

› Output: 3

💡 Note: The possible combinations are: [1,1,1], [1,2], [2,1]. Total of 3 different ways.

Constraints

1 ≤ nums.length ≤ 200
1 ≤ nums[i] ≤ 1000
All elements of nums are unique
1 ≤ target ≤ 1000
The number of possible combinations that add up to target is guaranteed to fit in a 32-bit integer

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with dp[0] = 1 (one way to make $0: use no coins)

Build Up

For each amount, count ways by adding each coin denomination to smaller amounts

Sequence Matters

Unlike traditional coin change, [quarter, dime] and [dime, quarter] are different sequences

Key Takeaway

🎯 Key Insight: Use dp[i] to store ways to make amount i, then dp[i] = sum of dp[i-coin] for all valid coins. This builds the solution efficiently from smaller subproblems.

Asked in

G Google 28 f Meta 22 a Amazon 35 ⊞ Microsoft 18

The optimal solution uses bottom-up dynamic programming with time complexity O(target × n). Create a DP array where dp[i] represents the number of ways to make sum i. The key insight is that dp[i] = sum of dp[i-num] for all valid numbers, building the solution iteratively from smaller subproblems.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive with Memoization	O(target * nums.length)	O(target)	Add memoization to avoid recalculating the same subproblems
Bottom-Up Dynamic Programming (Optimal)	O(target * nums.length)	O(target)	Build solution iteratively from smaller subproblems to target
Recursive Brute Force	O(target^nums.length)	O(target)	Try every possible combination recursively

Recursive with Memoization — Algorithm Steps

Create a memoization table (array or hash map)
Before making recursive call, check if result already exists in memo
If exists, return cached result immediately
If not, calculate result recursively and store in memo before returning

Visualization

Tap to expand

Step-by-Step Walkthrough

First calculation

Calculate and store result in memo

Cache hit

Return stored result immediately

Build solution

Use cached results to build final answer

Code -

solution.c — C

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

int dp(int* nums, int numsSize, int remaining, int* memo) {
    if (remaining == 0) return 1;
    if (remaining < 0) return 0;
    if (memo[remaining] != -1) return memo[remaining];
    
    int count = 0;
    for (int i = 0; i < numsSize; i++) {
        count += dp(nums, numsSize, remaining - nums[i], memo);
    }
    
    memo[remaining] = count;
    return count;
}

int combinationSum4(int* nums, int numsSize, int target) {
    int* memo = (int*)malloc((target + 1) * sizeof(int));
    for (int i = 0; i <= target; i++) memo[i] = -1;
    
    int result = dp(nums, numsSize, target, memo);
    free(memo);
    return result;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(target * nums.length)

Each subproblem from 0 to target is solved once, and for each we try all numbers in nums

✓ Linear Growth

Space Complexity

O(target)

Memoization table of size target plus recursion stack

✓ Linear Space

94.5K Views

High Frequency

~18 min Avg. Time

2.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

Recursive with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler