Length of the Longest Subsequence That Sums to Target

Length of the Longest Subsequence That Sums to Target - Problem

Given a 0-indexed array of integers nums and an integer target, find the length of the longest subsequence of nums that sums up to target.

A subsequence is derived from an array by deleting some or no elements without changing the order of the remaining elements. For example, from array [1,2,3,4], valid subsequences include [1,3], [2,4], and [1,2,3,4].

Your task: Return the maximum possible length of such a subsequence. If no subsequence exists that sums to target, return -1.

Example: For nums = [1,2,3,2] and target = 4, the longest subsequence is [1,3] or [2,2], both with length 2.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: The longest subsequence that sums to 4 is either [1,3] or [2,2], both have length 2.

example_2.py — Multiple Elements

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

› Output: 3

💡 Note: We can select any 3 elements from [1,1,1,1] to get sum 3, giving us length 3.

example_3.py — No Solution

$ Input: nums = [2,4,6], target = 5

› Output: -1

💡 Note: No subsequence of [2,4,6] can sum to 5, so we return -1.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
1 ≤ target ≤ 1000
All elements in nums are positive integers

Visualization

Tap to expand

0🪙Start1💰
1🪙2💰
1🪙3💰
2🪙4💰
2🪙TARGET!Optimal Paths Found:Path 1: Select coins [1💰, 3💰] → Sum = 4💰, Length = 2🪙Path 2: Select coins [2💰, 2💰] → Sum = 4💰, Length = 2🪙Maximum coins collected: 2🪙DP Transition:For each coin value 'v' and each sum 's':dp[s] = max(dp[s], dp[s-v] + 1)"Can we get better result by including this coin?"⚡ Process backwards to avoid double-counting!

Understanding the Visualization

Initialize Treasure Map

Create a map showing the maximum coins needed for each treasure value from 0 to target

Process Each Coin

For each coin type, update the map by considering whether to include it

Backward Update

Update from highest to lowest values to avoid using the same coin twice

Find Optimal Path

The answer is the maximum coins achievable for the target treasure value

Key Takeaway

🎯 Key Insight: This problem is a variant of the unbounded knapsack where we maximize count instead of value. DP lets us build optimal solutions incrementally!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses dynamic programming with time complexity O(n × target). We maintain a DP array where dp[sum] represents the maximum length of subsequence that achieves that sum. For each number, we iterate backwards through possible sums to avoid double-counting, updating the maximum length for each achievable sum.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n * target)	O(target)	Use DP to build up solutions for all possible sums, maximizing length
Brute Force (Generate All Subsequences)	O(2^n)	O(n)	Generate all possible subsequences and find the longest one that sums to target

Dynamic Programming (Optimal) — Algorithm Steps

Initialize DP array where dp[i] = maximum length to achieve sum i
Set dp[0] = 0 (empty subsequence has sum 0 and length 0)
For each number in the array, update DP table backwards
For each possible sum, decide whether to include current number
Return dp[target] if it exists, otherwise -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

dp[0] = 0, all others = -1

Process num=1

dp[1] = 1 (can achieve sum 1 with length 1)

Process num=2

dp[2] = 1, dp[3] = 2 (updating possible sums)

Final Result

dp[4] = 2 (maximum length for target sum)

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int lengthOfLongestSubsequence(int* nums, int numsSize, int target) {
    // dp[i] represents the maximum length of subsequence with sum i
    int* dp = (int*)malloc((target + 1) * sizeof(int));
    for (int i = 0; i <= target; i++) {
        dp[i] = -1;
    }
    dp[0] = 0; // Empty subsequence has sum 0 and length 0
    
    for (int i = 0; i < numsSize; i++) {
        int num = nums[i];
        // Iterate backwards to avoid using updated values in same iteration
        for (int currentSum = target; currentSum >= num; currentSum--) {
            if (dp[currentSum - num] != -1) {
                dp[currentSum] = max(dp[currentSum], dp[currentSum - num] + 1);
            }
        }
    }
    
    int result = dp[target];
    free(dp);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n * target)

We iterate through n elements and for each element, we check up to target sums

✓ Linear Growth

Space Complexity

O(target)

DP array of size target+1 to store maximum lengths for each possible sum

✓ Linear Space

42.0K Views

Medium Frequency

~25 min Avg. Time

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler