Find the Maximum Length of a Good Subsequence II

Find the Maximum Length of a Good Subsequence II - Problem

You are given an integer array nums and a non-negative integer k. Your task is to find the maximum possible length of a "good" subsequence from the array.

A subsequence seq is considered good if there are at most k positions where consecutive elements are different. More formally, there should be at most k indices i in the range [0, seq.length - 2] such that seq[i] != seq[i + 1].

Example: For array [1,2,1,1,3] with k=2, the subsequence [1,2,1,3] has 3 transitions (1→2, 2→1, 1→3), but we can only have 2, so we might choose [1,1,1] with length 3 and 0 transitions instead.

🎯 Goal: Return the maximum length of such a good subsequence.

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: The optimal subsequence is [1,2,1,1] with length 4. It has 2 transitions: 1→2 and 2→1, which equals our limit k=2.

example_2.py — No Transitions Allowed

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

› Output: 1

💡 Note: With k=0, no transitions are allowed, so we can only pick subsequences of identical elements. The maximum length is 1.

example_3.py — All Same Elements

$ Input: nums = [5,5,5,5], k = 1

› Output: 4

💡 Note: All elements are the same, so we can take the entire array with 0 transitions, well within our limit of k=1.

Visualization

Tap to expand

Understanding the Visualization

Start Processing

Begin with first bead, creating initial chain segments

Same Color Extension

When we see the same color, extend existing chains for free

Color Transition

When colors differ, use a precious connector to join chains

Optimize Choices

Choose the best combination to maximize total chain length

Key Takeaway

🎯 Key Insight: By modeling this as a DP problem where we track the best subsequence ending with each value and transition count, we avoid the exponential complexity of checking all subsequences while finding the optimal solution efficiently.

Time & Space Complexity

Time Complexity

⏱️

O(n * k * V)

n elements, k+1 transition states, V unique values in array

✓ Linear Growth

Space Complexity

O(k * V)

DP table storing max length for each (value, transition_count) pair

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 5000
1 ≤ nums[i] ≤ 10³
0 ≤ k ≤ min(nums.length - 1, 50)
Memory limit: 256 MB
Time limit: 2 seconds

Asked in

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

The optimal solution uses dynamic programming with state dp[value][transitions] to track the maximum subsequence length ending with each value using a specific number of transitions. The key insight is that we can either extend sequences of the same value for free, or transition from any other value at the cost of one transition. Time complexity is O(n × k × V) where V is the number of unique values.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subsequences)	O(2^n * n)	O(n)	Generate all possible subsequences and check each one
Dynamic Programming (Optimal)	O(n * k * V)	O(k * V)	Use DP to track best subsequence ending at each value with each transition count

Brute Force (Generate All Subsequences) — Algorithm Steps

Generate all 2^n possible subsequences of the array
For each subsequence, count transitions where adjacent elements differ
Keep track of the maximum length among valid subsequences
Return the maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsequence

Use bit mask to select elements

Count Transitions

Check adjacent elements for differences

Validate

Check if transitions ≤ k

Track Maximum

Update max length if valid

Code -

solution.c — C

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

int maximumLength(int* nums, int numsSize, int k) {
    int maxLength = 0;
    
    // Generate all subsequences
    for (int mask = 1; mask < (1 << numsSize); mask++) {
        int subsequence[1000];
        int subLen = 0;
        
        for (int i = 0; i < numsSize; i++) {
            if (mask & (1 << i)) {
                subsequence[subLen++] = nums[i];
            }
        }
        
        // Count transitions
        int transitions = 0;
        for (int i = 0; i < subLen - 1; i++) {
            if (subsequence[i] != subsequence[i + 1]) {
                transitions++;
            }
        }
        
        // Check if good
        if (transitions <= k && subLen > maxLength) {
            maxLength = subLen;
        }
    }
    
    return maxLength;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n)

2^n subsequences to generate, each taking O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current subsequence and recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 5000
1 ≤ nums[i] ≤ 10³
0 ≤ k ≤ min(nums.length - 1, 50)
Memory limit: 256 MB
Time limit: 2 seconds

43.7K Views

Medium-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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate All Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler