Find the Maximum Length of Valid Subsequence I

Find the Maximum Length of Valid Subsequence I - Problem

🎯 Find the Maximum Length of Valid Subsequence

You are given an integer array nums. Your task is to find the longest valid subsequence where consecutive pairs have a consistent sum pattern.

A subsequence sub of length x is considered valid if:

All consecutive pairs have the same parity: (sub[0] + sub[1]) % 2 == (sub[1] + sub[2]) % 2 == ... == (sub[x-2] + sub[x-1]) % 2

Key Insight: The sum of two numbers has the same parity if both numbers are even, both are odd, or one is even and one is odd consistently throughout the subsequence.

Example: In [1, 2, 3, 4], the subsequence [1, 2, 3] is valid because (1+2)%2 = 1 and (2+3)%2 = 1.

Input & Output

example_1.py — Basic case

$ Input: [1, 2, 3, 4]

› Output: 4

💡 Note: The entire array [1,2,3,4] forms a valid subsequence because all consecutive sums are odd: (1+2)%2=1, (2+3)%2=1, (3+4)%2=1. This gives us the maximum length of 4.

example_2.py — Mixed parities

$ Input: [1, 2, 1, 1, 2, 1, 2]

› Output: 6

💡 Note: We can form the subsequence [1,2,1,1,2,1] where consecutive sums alternate between odd and even in a consistent pattern, giving length 6.

example_3.py — Single element

$ Input: [1]

› Output: 1

💡 Note: With only one element, the longest valid subsequence has length 1 (no consecutive pairs to check).

Constraints

1 ≤ nums.length ≤ 10³
1 ≤ nums[i] ≤ 10³
The array contains positive integers only

Visualization

Tap to expand

Understanding the Visualization

Identify Patterns

Red+Red=Blue, Blue+Blue=Blue (same colors give blue), Red+Blue=Red (different colors give red)

Track Sequences

For each mixing pattern, track the longest sequence ending with each color

Find Maximum

The answer is the longest sequence among all valid patterns

Key Takeaway

🎯 Key Insight: There are only 3 possible valid dance patterns, and we can efficiently find the longest sequence for each pattern using dynamic programming in O(n) time.

Asked in

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

The optimal approach recognizes that there are only 2 possible parity patterns for consecutive sums: even (0) or odd (1). Using dynamic programming, we track the maximum subsequence length for each pattern ending with even/odd numbers, achieving O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Pattern Recognition	O(n)	O(1)	Recognize there are only 3 possible valid patterns and find the longest for each

Optimized Pattern Recognition — Algorithm Steps

Identify that consecutive pair sums can only be even (0 mod 2) or odd (1 mod 2)
For pattern 0 (even sums): find longest alternating even-odd or all-even or all-odd subsequence
For pattern 1 (odd sums): find longest alternating even-odd subsequence
Use dynamic programming to track longest subsequence ending with even/odd number for each pattern

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Patterns

Recognize only 2 possible consecutive sum parities: even (0) or odd (1)

Track States

For each pattern, track max length ending with even/odd number

Update States

Process each element and update DP states based on valid transitions

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 maxLength(int* nums, int n) {
    if (n <= 1) return n;
    
    // dp[pattern][last_parity] = max length
    int dp[2][2] = {{1, 1}, {1, 1}};
    
    for (int i = 1; i < n; i++) {
        int curr = nums[i] % 2;
        int prev = nums[i-1] % 2;
        
        int newDp[2][2] = {{1, 1}, {1, 1}};
        
        // Pattern 0: consecutive sums are even
        if (curr == prev) {
            newDp[0][curr] = max(dp[0][prev] + 1, newDp[0][curr]);
        }
        
        // Pattern 1: consecutive sums are odd
        if (curr != prev) {
            newDp[1][curr] = max(dp[1][prev] + 1, newDp[1][curr]);
        }
        
        // Carry forward previous values
        for (int p = 0; p < 2; p++) {
            for (int last = 0; last < 2; last++) {
                newDp[p][last] = max(newDp[p][last], dp[p][last]);
            }
        }
        
        // Update dp
        for (int p = 0; p < 2; p++) {
            for (int last = 0; last < 2; last++) {
                dp[p][last] = newDp[p][last];
            }
        }
    }
    
    int result = dp[0][0];
    result = max(result, dp[0][1]);
    result = max(result, dp[1][0]);
    result = max(result, dp[1][1]);
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    if (strstr(line, "[]") != NULL) {
        printf("0\n");
        return 0;
    }
    
    // Parse input [1,2,3,4]
    int nums[100];
    int n = 0;
    
    char* token = strtok(line, "[],\n");
    while (token != NULL && n < 100) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", maxLength(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, constant work per element

✓ Linear Growth

Space Complexity

O(1)

Only need to track a few variables for each pattern

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

847 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 Valid Subsequence

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Optimized Pattern Recognition — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler