Combination Sum IV

Combination Sum IV - Problem

Given an array of distinct integers nums and a target integer target, return the number of possible combinations that add up to target.

The test cases are generated so that the answer can fit in a 32-bit integer.

Note: Different sequences are counted as different combinations. For example, [1,2] and [2,1] are considered different combinations.

Input & Output

Example 1 — 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], [1,3], [3,1], [2,2]. Total of 7 combinations.

Example 2 — Single Element

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

› Output: 0

💡 Note: Since 9 > 3, there's no way to form target 3 using only number 9. Answer is 0.

Example 3 — Perfect Match

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

› Output: 3

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

Constraints

1 ≤ nums.length ≤ 200
1 ≤ nums[i] ≤ 1000
All elements in nums are unique
1 ≤ target ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8 M Microsoft 6

The key insight is that this is an unbounded knapsack problem where order matters. We can use dynamic programming where dp[i] represents the number of ways to form amount i. For each amount, we try adding each number from nums. Time: O(target × nums.length), Space: O(target)

Common Approaches

✓ Backtracking

⏱️ Time: N/A Space: N/A

Bottom-Up Dynamic Programming

⏱️ Time: O(target × nums.length) Space: O(target)

Create a DP array where dp[i] represents the number of ways to make amount i. Start with dp[0] = 1 (one way to make 0), then for each amount from 1 to target, try adding each number from nums.

Recursion with Memoization

⏱️ Time: O(target × nums.length) Space: O(target)

Same recursive approach but store results of each target value in a memo table. When we encounter the same target again, return the cached result instead of recalculating.

Recursive Brute Force

⏱️ Time: O(target^nums.length) Space: O(target)

For each target value, recursively try subtracting each number from nums and count all valid combinations. This explores all possible sequences but recalculates the same subproblems multiple times.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

char getRotation(char digit) {
    switch(digit) {
        case '0': return '0';
        case '1': return '1';
        case '6': return '9';
        case '8': return '8';
        case '9': return '6';
        default: return '\0';
    }
}

int isConfusing(long long num) {
    char s[20], rotated[20];
    sprintf(s, "%lld", num);
    int len = strlen(s);
    
    for (int i = 0; i < len; i++) {
        rotated[i] = getRotation(s[len - 1 - i]);
    }
    rotated[len] = '\0';
    
    long long rotatedNum = atoll(rotated);
    sprintf(rotated, "%lld", rotatedNum);
    
    return strcmp(rotated, s) != 0;
}

int backtrack(long long current, int n) {
    if (current > n) {
        return 0;
    }
    
    int count = 0;
    if (current != 0 && isConfusing(current)) {
        count += 1;
    }
    
    int digits[] = {0, 1, 6, 8, 9};
    for (int i = 0; i < 5; i++) {
        // Skip digit 0 when current is 0 to avoid infinite recursion
        if (current == 0 && digits[i] == 0) {
            continue;
        }
        long long nextNum = current * 10 + digits[i];
        if (nextNum <= n) {
            count += backtrack(nextNum, n);
        }
    }
    
    return count;
}

int solution(int n) {
    return backtrack(0, n);
}

int main() {
    int n;
    scanf("%d", &n);
    
    int result = solution(n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

380.0K Views

Medium Frequency

~25 min Avg. Time

4.5K 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