Find the Maximum Length of Valid Subsequence II

Find the Maximum Length of Valid Subsequence II - Problem

You are given an integer array nums and a positive integer k.

A subsequence sub of nums with length x is called valid if it satisfies:

(sub[0] + sub[1]) % k == (sub[1] + sub[2]) % k == ... == (sub[x - 2] + sub[x - 1]) % k

Return the length of the longest valid subsequence of nums.

Input & Output

Example 1 — Basic Valid Subsequence

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

› Output: 2

💡 Note: The longest valid subsequence has length 2. For example, [1,4] where (1+4)%3=2, or [2,3] where (2+3)%3=2.

Example 2 — Single Element

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

› Output: 1

💡 Note: Single element subsequence [1] is valid by definition, length=1

Example 3 — Multiple Valid Pairs

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

› Output: 4

💡 Note: The subsequence [1,2,1,2] is valid: (1+2)%2=1, (2+1)%2=1, (1+2)%2=1. All consecutive pairs have same remainder.

Constraints

1 ≤ nums.length ≤ 10³
1 ≤ nums[i] ≤ 10⁶
2 ≤ k ≤ 10³

Visualization

Tap to expand

Asked in

G Google 25 M Meta 20 A Amazon 18 M Microsoft 15

The key insight is to use dynamic programming to track the longest valid subsequence ending with each pair of remainders. The optimal approach uses a 2D DP table where dp[i][j] represents the longest subsequence ending with remainders i and j. Time: O(n × k²), Space: O(k²)

Common Approaches

✓ Brute Force - Try All Subsequences

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

Generate every possible subsequence of the array and check if consecutive pairs have the same modulo sum. This ensures we find the optimal answer but is very slow.

Dynamic Programming - Track Remainder Pairs

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

For each remainder pair (i,j), track the longest valid subsequence ending with numbers having remainders i and j. This avoids checking all subsequences by building solutions incrementally.

Optimized DP with Better State Management

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

This optimized version uses cleaner state management where dp[r1][r2] represents the longest sequence where consecutive sums have remainder (r1+r2)%k. We iterate through positions and update states more efficiently.

Brute Force - Try All Subsequences — Algorithm Steps

Generate all 2^n subsequences
For each subsequence, check if consecutive pairs have same (a+b)%k
Return length of longest valid subsequence

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all possible subsequences

Validate

Check if consecutive pairs have same modulo

Track

Keep track of longest valid subsequence

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 solution(int* nums, int numsSize, int k) {
    if (numsSize == 1) return 1;
    
    int maxLength = 1;
    
    // For each possible remainder target
    for (int target = 0; target < k; target++) {
        // dp[i][j] = longest valid subsequence ending with remainders i, j
        int dp[100][100] = {0};
        
        for (int idx = 0; idx < numsSize; idx++) {
            int currRemainder = nums[idx] % k;
            
            // Try to extend existing sequences
            for (int prevRemainder = 0; prevRemainder < k; prevRemainder++) {
                if ((prevRemainder + currRemainder) % k == target) {
                    // Check if we can start a new sequence of length 2
                    dp[prevRemainder][currRemainder] = max(
                        dp[prevRemainder][currRemainder], 2
                    );
                    
                    // Try to extend sequences ending with prevRemainder
                    for (int startRemainder = 0; startRemainder < k; startRemainder++) {
                        if (dp[startRemainder][prevRemainder] >= 2) {
                            dp[prevRemainder][currRemainder] = max(
                                dp[prevRemainder][currRemainder],
                                dp[startRemainder][prevRemainder] + 1
                            );
                        }
                    }
                }
            }
        }
        
        // Find maximum for this target
        for (int i = 0; i < k; i++) {
            for (int j = 0; j < k; j++) {
                maxLength = max(maxLength, dp[i][j]);
            }
        }
    }
    
    return maxLength;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int numsSize = 0;
    
    if (strcmp(line, "[]\n") != 0) {
        char* token = strtok(line, "[,]");
        while (token != NULL) {
            if (strcmp(token, "\n") != 0 && strcmp(token, "") != 0) {
                nums[numsSize++] = atoi(token);
            }
            token = strtok(NULL, "[,]");
        }
    }
    
    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 takes O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(n)

Store current subsequence during generation

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~35 min Avg. Time

450 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

Brute Force - Try All Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler