Longest Subsequence With Decreasing Adjacent Difference

Longest Subsequence With Decreasing Adjacent Difference - Problem

Given an array of integers nums, find the length of the longest subsequence where the absolute differences between consecutive elements form a non-increasing sequence.

For a subsequence seq₀, seq₁, seq₂, ..., seqₘ, the condition is:
|seq₁ - seq₀| ≥ |seq₂ - seq₁| ≥ ... ≥ |seqₘ - seqₘ₋₁|

Example: In array [4, 2, 1, 3, 5], subsequence [4, 1, 3] has differences [3, 2] which is non-increasing, giving us a length of 3.

Your task is to return the maximum possible length of such a subsequence.

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: The longest valid subsequence is [4, 1, 3] with absolute differences [3, 2]. Since 3 ≥ 2, this forms a valid non-increasing sequence of differences.

example_2.py — All Same Differences

$ Input: [1, 3, 5, 7, 9]

› Output: 5

💡 Note: The entire array [1, 3, 5, 7, 9] has differences [2, 2, 2, 2]. Since all differences are equal (2 ≥ 2 ≥ 2 ≥ 2), the entire sequence is valid.

example_3.py — Single Element

$ Input: [5]

› Output: 1

💡 Note: A single element always forms a valid subsequence of length 1, as there are no differences to check.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
The array may contain duplicate elements

Visualization

Tap to expand

Understanding the Visualization

Identify Elements

Start with the input array and consider each element as a potential part of our subsequence

Calculate Differences

For each pair of elements, calculate the absolute difference that would be used in our subsequence

Build DP State

Track the longest valid subsequence ending at each position with each possible last difference

Extend Subsequences

For each new position, extend previous subsequences where the difference constraint is satisfied

Find Maximum

The answer is the maximum length across all valid subsequences

Key Takeaway

🎯 Key Insight: Use DP to track the longest valid subsequence ending at each position with each possible last difference, allowing efficient extension of subsequences while maintaining the non-increasing constraint.

Asked in

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

The optimal approach uses Dynamic Programming with state dp[i][diff] representing the longest valid subsequence ending at position i with last difference diff. For each pair of positions, we calculate the absolute difference and extend valid subsequences where the previous difference is ≥ current difference, ensuring the non-increasing property.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n² × D)	O(n × D)	Use DP to track longest subsequences ending at each position with each possible last difference
Brute Force (Generate All Subsequences)	O(n × 2^n)	O(n)	Generate all possible subsequences and check if their differences are non-increasing

Dynamic Programming (Optimal) — Algorithm Steps

Create a DP table where dp[i][diff] = longest subsequence ending at index i with last difference 'diff'
For each position i, consider all previous positions j < i
Calculate the absolute difference |nums[i] - nums[j]|
For each valid previous difference that is ≥ current difference, extend the subsequence
Return the maximum length found across all positions and differences

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Create DP table for each position and difference combination

Calculate Differences

For each pair (i,j), calculate absolute difference

Extend Subsequences

Extend valid subsequences where prev_diff ≥ curr_diff

Track Maximum

Keep track of the maximum length across all states

Code -

solution.c — C

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

#define MAX_DIFF 1001
#define MAX_N 1001

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int max(int a, int b) {
    return a > b ? a : b;
}

int longestSubsequence(int* nums, int n) {
    if (n <= 1) return n;
    
    // dp[i][diff] = longest subsequence ending at i with last difference 'diff'
    int dp[MAX_N][MAX_DIFF];
    memset(dp, 0, sizeof(dp));
    
    int maxLength = 1;
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < i; j++) {
            int currDiff = abs_val(nums[i] - nums[j]);
            if (currDiff >= MAX_DIFF) continue;
            
            // Case 1: Start new subsequence of length 2
            dp[i][currDiff] = max(dp[i][currDiff], 2);
            
            // Case 2: Extend existing subsequences from position j
            for (int prevDiff = currDiff; prevDiff < MAX_DIFF; prevDiff++) {
                if (dp[j][prevDiff] > 0) {
                    dp[i][currDiff] = max(dp[i][currDiff], dp[j][prevDiff] + 1);
                }
            }
            
            maxLength = max(maxLength, dp[i][currDiff]);
        }
    }
    
    return maxLength;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[MAX_N];
    int n = 0;
    
    char* token = strtok(line, "[],\n ");
    while (token != NULL && n < MAX_N) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", longestSubsequence(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × D)

n² for all pairs of positions, D for the range of possible differences

⚠ Quadratic Growth

Space Complexity

O(n × D)

DP table storing longest subsequence for each position and difference

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

1.2K 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 (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler