Find the Maximum Length of a Good Subsequence I - Problem

You are given an integer array nums and a non-negative integer k.

A subsequence is called "good" if there are at most k positions where consecutive elements in the subsequence are different. In other words, if seq[i] != seq[i+1] for at most k indices i.

Your goal is to find the maximum possible length of a good subsequence from the given array.

Example: If nums = [1,2,1,1,3] and k = 2, you could choose subsequence [1,1,1,3] which has 2 transitions (1→1: no transition, 1→1: no transition, 1→3: transition), totaling 1 transition ≤ 2, so it's valid with length 4.

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: We can choose subsequence [1,1,1,3]. This has transitions: 1→1 (same), 1→1 (same), 1→3 (different). Only 1 transition ≤ 2, so it's valid with length 4.

example_2.py — No Changes Allowed

$ Input: nums = [1,2,3,4,5], k = 0

› Output: 1

💡 Note: With k=0, we cannot have any transitions. We can only choose subsequences with identical elements. The longest such subsequence has length 1.

example_3.py — Many Changes Allowed

$ Input: nums = [1,2,1,1,3], k = 10

› Output: 5

💡 Note: With k=10, we have more than enough changes allowed. We can take the entire array [1,2,1,1,3] which has 3 transitions, well within the limit.

Constraints

1 ≤ nums.length ≤ 500
1 ≤ nums[i] ≤ 10³
0 ≤ k ≤ min(nums.length, 25)
Note: The constraint on k being at most 25 makes the DP approach very efficient

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal solution uses dynamic programming with state dp[changes][value] representing the maximum length of a good subsequence ending with a specific value using a certain number of changes. For each element, we can either extend existing subsequences with the same value (no cost) or different values (1 change cost). The time complexity is O(n × k × unique_values).

Common Approaches

✓ Dynamic Programming (Optimal)

⏱️ Time: O(n * k * unique_values) Space: O(k * unique_values)

Use dynamic programming where dp[i][j] represents the maximum length of a good subsequence ending at position i with j changes used. For each position, we can either extend existing subsequences with the same value or start new ones by using a change.

Dynamic Programming (Optimal) — Algorithm Steps

Initialize DP table: dp[changes_used][last_value] = max_length
For each element, try extending subsequences with same value (no cost)
Try extending subsequences with different values (costs 1 change)
Track maximum length across all states
Return the overall maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Set up DP table for changes and values

Process Element

Update states for current element

Track Maximum

Maintain maximum length for each change count

Code -

solution.c — C

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

static int dp[51][1001];
static int maxDp[51];
static int newDp[51][1001];
static int newMaxDp[51];

int maximumLength(int* nums, int numsSize, int k) {
    // Initialize arrays
    memset(dp, 0, sizeof(dp));
    memset(maxDp, 0, sizeof(maxDp));
    
    for (int i = 0; i < numsSize; i++) {
        int num = nums[i];
        
        // Copy current state
        memcpy(newDp, dp, sizeof(dp));
        memcpy(newMaxDp, maxDp, sizeof(maxDp));
        
        for (int changes = 0; changes <= k; changes++) {
            // Extend subsequence with same value
            int extended = dp[changes][num] + 1;
            if (extended > newDp[changes][num]) {
                newDp[changes][num] = extended;
            }
            
            // Use one change
            if (changes > 0) {
                int withChange = maxDp[changes - 1] + 1;
                if (withChange > newDp[changes][num]) {
                    newDp[changes][num] = withChange;
                }
            }
            
            // Update max for this change count
            if (newDp[changes][num] > newMaxDp[changes]) {
                newMaxDp[changes] = newDp[changes][num];
            }
        }
        
        memcpy(dp, newDp, sizeof(dp));
        memcpy(maxDp, newMaxDp, sizeof(maxDp));
    }
    
    int result = 0;
    for (int i = 0; i <= k; i++) {
        if (maxDp[i] > result) {
            result = maxDp[i];
        }
    }
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[500];
    int numsSize = 0;
    
    char* token = strtok(line, ",\n");
    while (token != NULL && numsSize < 500) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",\n");
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", maximumLength(nums, numsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * k * unique_values)

For each position, we check all possible previous values and change counts

✓ Linear Growth

Space Complexity

O(k * unique_values)

DP table storing states for changes and values

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

890 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

Find the Maximum Length of a Good Subsequence I - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler