Find the Maximum Length of Valid Subsequence I

Find the Maximum Length of Valid Subsequence I - Problem

You are given an integer array nums. A subsequence sub of nums with length x is called valid if it satisfies:

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

Return the length of the longest valid subsequence of nums.

A subsequence is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.

Input & Output

Example 1 — Basic Mixed Array

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

› Output: 4

💡 Note: We can select the entire array [1,2,3,4]. Adjacent sums: (1+2)%2=1, (2+3)%2=1, (3+4)%2=1. All have the same parity.

Example 2 — All Same Parity

$ Input: nums = [2,4,6,8]

› Output: 4

💡 Note: All numbers are even. We can select all: [2,4,6,8]. Adjacent sums: (2+4)%2=0, (4+6)%2=0, (6+8)%2=0. All even sums.

Example 3 — Small Array

$ Input: nums = [1,3]

› Output: 2

💡 Note: Only one pair possible: [1,3]. Sum: (1+3)%2=0. Valid subsequence of length 2.

Constraints

1 ≤ nums.length ≤ 10³
1 ≤ nums[i] ≤ 100

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 10

The key insight is recognizing that only 4 parity patterns exist for adjacent sums. The optimal approach tracks all patterns in a single O(n) pass using O(1) space, achieving maximum efficiency.

Common Approaches

✓ Brute Force Optimized

⏱️ Time: N/A Space: N/A

Brute Force - Try All Subsequences

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

For each possible subsequence, check if all adjacent pairs have the same parity sum. This involves generating 2^n subsequences and validating each one.

Dynamic Programming - Pattern Recognition

⏱️ Time: O(n) Space: O(1)

Since adjacent sums can only have 4 parity patterns (even+even, even+odd, odd+even, odd+odd), we can use dynamic programming to track the longest sequence ending at each position for each pattern.

Optimized - Smart Pattern Tracking

⏱️ Time: O(n) Space: O(1)

Instead of using DP arrays, we can directly track the maximum length achievable for each of the 4 parity patterns in one pass. This is more space-efficient and equally fast.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

8.5K Views

Medium Frequency

~15 min Avg. Time

234 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