Find the Maximum Length of Valid Subsequence II

Find the Maximum Length of Valid Subsequence II - Problem

Find the Maximum Length of Valid Subsequence II

You are given an integer array nums and a positive integer k. Your task is to find the longest valid subsequence from the array.

A subsequence sub of length x is considered valid if all consecutive pairs in the subsequence have the same remainder when their sum is divided by k. In other words:

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

For example, if nums = [1, 2, 3, 4, 5] and k = 3, the subsequence [1, 2, 4] is valid because (1+2)%3 = 0 and (2+4)%3 = 0.

Goal: Return the length of the longest valid subsequence.

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: The longest valid subsequence is [1,2,3,4]. Here (1+2)%3=0, (2+3)%3=2, but we can find [2,3,5,2] where all consecutive sums have remainder 2 when divided by 3, giving us length 4.

example_2.py — All Same Remainder

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

› Output: 4

💡 Note: We can form subsequence [1,2,1,5] where all elements have remainder 1 or 2 mod 3, and consecutive sums maintain the same remainder pattern.

example_3.py — Small k

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

› Output: 2

💡 Note: The entire array [1,2] forms a valid subsequence since (1+2)%2=1, and there's only one consecutive pair.

Constraints

1 ≤ nums.length ≤ 10³
1 ≤ nums[i] ≤ 10⁶
1 ≤ k ≤ 10³
A subsequence maintains the relative order of elements from the original array

Visualization

Tap to expand

Understanding the Visualization

Choose Target Harmony

Pick a target remainder (0 to k-1) that represents the harmonic interval we want

Track Note Classes

For each remainder class, track the longest harmony chain ending with that class

Extend Chains

For each new note, find which previous note class creates our target harmony, then extend that chain

Update Maximum

Keep track of the longest harmony chain found across all target harmonies

Key Takeaway

🎯 Key Insight: By treating each remainder class as a note type and using dynamic programming to track the longest harmony chains, we can efficiently build the optimal musical sequence with consistent harmonic intervals.

Asked in

G Google 42 f Meta 35 a Amazon 28 ⊞ Microsoft 22

The optimal solution uses dynamic programming to efficiently find the longest valid subsequence. For each possible target remainder (0 to k-1), we maintain a DP array tracking the longest subsequence ending with each remainder class. The key insight is that if we want consecutive sums to have remainder r, and current element has remainder class j, we need the previous element to have remainder class i where (i+j) % k = r. Time complexity: O(n×k), Space complexity: O(k).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Hash Map (Optimal)	O(n × k)	O(k)	Use DP to track longest valid subsequence ending with each remainder pattern
Brute Force (Try All Subsequences)	O(n * 2^n)	O(n)	Generate all possible subsequences and check validity

Dynamic Programming with Hash Map (Optimal) — Algorithm Steps

For each target remainder r from 0 to k-1, use DP to find longest subsequence
For each element, calculate its remainder class modulo k
Use dp[i] to represent longest subsequence ending with remainder class i
For each element with remainder class j, update dp[j] based on dp[i] where (i+j)%k = r
Return the maximum length found across all target remainders

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Create DP array for each remainder class

Process Element

Update DP based on element's remainder class

Find Maximum

Track the maximum length across all states

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 maximumLength(int* nums, int numsSize, int k) {
    int maxLength = 0;
    
    // Try each possible target remainder
    for (int targetRemainder = 0; targetRemainder < k; targetRemainder++) {
        // dp[i] = longest subsequence ending with remainder class i
        int dp[1000] = {0}; // assuming k <= 1000
        
        for (int i = 0; i < numsSize; i++) {
            int remainderClass = nums[i] % k;
            
            // Find the best previous remainder class that gives targetRemainder
            int bestPrevLength = 0;
            for (int prevClass = 0; prevClass < k; prevClass++) {
                if ((prevClass + remainderClass) % k == targetRemainder) {
                    bestPrevLength = max(bestPrevLength, dp[prevClass]);
                }
            }
            
            // Update dp for current remainder class
            dp[remainderClass] = max(dp[remainderClass], bestPrevLength + 1);
            maxLength = max(maxLength, dp[remainderClass]);
        }
    }
    
    return maxLength;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n × k)

We iterate through n elements for each of k possible remainders

✓ Linear Growth

Space Complexity

O(k)

We store DP state for k remainder classes

✓ Linear Space

38.2K Views

Medium Frequency

~25 min Avg. Time

1.3K 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 with Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler