Find the Maximum Length of a Good Subsequence II - Problem

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

A sequence of integers seq is called good if there are at most k indices i in the range [0, seq.length - 2] such that seq[i] != seq[i + 1].

Return the maximum possible length of a good subsequence of nums.

Input & Output

Example 1 — Basic Good Subsequence

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

› Output: 3

💡 Note: The best subsequence is [1,1,1] (taking elements at indices 0,2,3) with 0 transitions, giving length 3. We cannot take the full array [1,2,1,1] as it would have 2 transitions (1≠2 and 2≠1), exceeding k=1.

Example 2 — Limited Transitions

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

› Output: 3

💡 Note: Best subsequence is [1,2,3] with 2 transitions: 1≠2 and 2≠3. We cannot include more elements without exceeding k=2 transitions.

Example 3 — No Transitions Allowed

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

› Output: 3

💡 Note: With k=0, no adjacent elements can be different. Best subsequence is [1,1,1] with length 3 (all same elements).

Constraints

1 ≤ nums.length ≤ 5000
-10⁹ ≤ nums[i] ≤ 10⁹
0 ≤ k ≤ min(nums.length, 25)

Visualization

Tap to expand

Asked in

G Google 25 M Meta 18 a Amazon 15 M Microsoft 12

The key insight is to use dynamic programming to track the maximum length of subsequences ending with each value and number of transitions used. The optimal approach uses hash maps to efficiently store states, achieving O(n × k × unique_values) time complexity. Best approach: Hash Map DP with Time: O(n × k × V), Space: O(k × V).

Common Approaches

✓ Brute Force - Generate All Subsequences

⏱️ Time: O(2^n × n) Space: O(n)

For each possible subsequence of the array, count the number of adjacent different elements. If the count is at most k, track the maximum length found.

Dynamic Programming with State Tracking

⏱️ Time: O(n² × k) Space: O(n × k)

Create a DP table where dp[i][j] represents the maximum length of good subsequence ending at position i using exactly j transitions. Build the answer by considering whether to extend existing sequences or start new ones.

Optimized DP with Hash Map

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

Instead of checking all previous positions, use hash maps to store the best length for sequences ending with each distinct value and number of transitions. This reduces the inner loop complexity.

Brute Force - Generate All Subsequences — Algorithm Steps

Step 1: Generate all 2^n possible subsequences
Step 2: For each subsequence, count adjacent differences
Step 3: Track maximum length where differences ≤ k

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all 2^n subsequences using bit masks

Validate

Count adjacent differences in each subsequence

Track Max

Keep the longest valid subsequence

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int k) {
    int maxLength = 0;
    
    // Generate all subsequences using bit manipulation
    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 adjacent different elements
        int differences = 0;
        for (int i = 0; i < subLen - 1; i++) {
            if (subsequence[i] != subsequence[i + 1]) {
                differences++;
            }
        }
        
        // Check if this is a good subsequence
        if (differences <= k) {
            if (subLen > maxLength) {
                maxLength = subLen;
            }
        }
    }
    
    return maxLength;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array using strtol-based parsing
    int nums[1000];
    int numsSize = 0;
    char* p = line;
    
    // Find the opening bracket
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse number using strtol
        nums[numsSize++] = (int)strtol(p, &p, 10);
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, numsSize, k);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n)

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

⚠ Quadratic Growth

Space Complexity

O(n)

Store current subsequence and recursion stack

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~35 min Avg. Time

876 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 II - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Generate All Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler