Longest Subsequence With Decreasing Adjacent Difference

Longest Subsequence With Decreasing Adjacent Difference - Problem

You are given an array of integers nums. Your task is to find the length of the longest subsequence seq of nums, such that the absolute differences between consecutive elements form a non-increasing sequence of integers.

In other words, for a subsequence seq₀, seq₁, seq₂, ..., seqₘ of nums, we need:

|seq₁ - seq₀| ≥ |seq₂ - seq₁| ≥ ... ≥ |seqₘ - seqₘ₋₁|

Return the length of such a subsequence.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: One valid subsequence is [4,7,2] with differences [3,5]. Since 3 ≤ 5 is false, we need [7,4,2] with differences [3,2] where 3 ≥ 2 ✓. Actually, [4,2,8] gives differences [2,6] which is invalid. The longest valid is [7,2] with length 2, but [4,7,2,8] checking all: [4,7] diff=3, [7,2,8] diffs=[5,6] invalid. Best is [4,7,8] with diffs=[3,1] where 3≥1 ✓, giving length 3.

Example 2 — Decreasing Differences

$ Input: nums = [10,5,3,2]

› Output: 4

💡 Note: The subsequence [10,5,3,2] has differences [5,2,1]. Since 5 ≥ 2 ≥ 1, this forms a valid non-increasing sequence of differences. The entire array can be used, giving length 4.

Example 3 — Single Element

$ Input: nums = [1]

› Output: 1

💡 Note: A single element forms a valid subsequence of length 1 (no differences to check).

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

This problem requires finding the longest subsequence where absolute differences between consecutive elements form a non-increasing sequence. The key insight is to use dynamic programming with states tracking the last two elements of each subsequence. The optimal approach uses DP with HashMap for efficient state management. Time: O(n³), Space: O(n²).

Common Approaches

✓ Trie

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

Brute Force - Generate All Subsequences

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

Generate every possible subsequence of the array and for each one, check if the absolute differences between consecutive elements form a non-increasing sequence. Keep track of the maximum length found.

Dynamic Programming - 2D State

⏱️ Time: O(n³) Space: O(n²)

Use dynamic programming where dp[i][j][k] represents the maximum length of subsequence ending at position i with last element j and last difference k. Since differences can be large, we optimize by tracking only valid transitions.

Optimized DP with HashMap

⏱️ Time: O(n³) Space: O(n²)

An optimized version that uses HashMap to efficiently store and lookup DP states. We iterate through each element and try to extend all existing valid subsequences, keeping track of the maximum length achieved.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define ALPHABET_SIZE 26
#define MAX_KEYS 1000
#define MAX_LEN 100
#define MAX_OPS 100

typedef struct TrieNode {
    struct TrieNode* children[ALPHABET_SIZE];
    int sum;
} TrieNode;

typedef struct {
    TrieNode* root;
    char keys[MAX_KEYS][MAX_LEN];
    int values[MAX_KEYS];
    int size;
} MapSum;

TrieNode* createNode() {
    TrieNode* node = (TrieNode*)calloc(1, sizeof(TrieNode));
    return node;
}

MapSum* mapSumCreate() {
    MapSum* obj = (MapSum*)malloc(sizeof(MapSum));
    obj->root = createNode();
    obj->size = 0;
    return obj;
}

void mapSumInsert(MapSum* obj, char* key, int val) {
    int delta = val;
    for (int i = 0; i < obj->size; i++) {
        if (strcmp(obj->keys[i], key) == 0) {
            delta = val - obj->values[i];
            obj->values[i] = val;
            break;
        }
    }
    if (delta == val) {
        strcpy(obj->keys[obj->size], key);
        obj->values[obj->size] = val;
        obj->size++;
    }
    
    TrieNode* node = obj->root;
    for (int i = 0; key[i]; i++) {
        int idx = key[i] - 'a';
        if (!node->children[idx]) {
            node->children[idx] = createNode();
        }
        node = node->children[idx];
        node->sum += delta;
    }
}

int mapSumSum(MapSum* obj, char* prefix) {
    TrieNode* node = obj->root;
    for (int i = 0; prefix[i]; i++) {
        int idx = prefix[i] - 'a';
        if (!node->children[idx]) {
            return 0;
        }
        node = node->children[idx];
    }
    return node->sum;
}

void trim(char* str) {
    int len = strlen(str);
    while (len > 0 && isspace(str[len-1])) len--;
    str[len] = '\0';
    
    char* start = str;
    while (*start && isspace(*start)) start++;
    if (start != str) {
        memmove(str, start, strlen(start) + 1);
    }
}

void removeQuotes(char* str) {
    int len = strlen(str);
    if (len >= 2 && str[0] == '"' && str[len-1] == '"') {
        memmove(str, str + 1, len - 2);
        str[len-2] = '\0';
    }
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char opsLine[1000], valsLine[2000];
    fgets(opsLine, sizeof(opsLine), stdin);
    fgets(valsLine, sizeof(valsLine), stdin);
    
    // Remove newlines
    opsLine[strcspn(opsLine, "\n")] = 0;
    valsLine[strcspn(valsLine, "\n")] = 0;
    
    // Parse operations
    char operations[MAX_OPS][20];
    int opCount = 0;
    
    char* opsStr = opsLine + 1; // Skip [
    opsStr[strlen(opsStr) - 1] = '\0'; // Remove ]
    
    char* token = strtok(opsStr, ",");
    while (token != NULL && opCount < MAX_OPS) {
        trim(token);
        removeQuotes(token);
        strcpy(operations[opCount], token);
        opCount++;
        token = strtok(NULL, ",");
    }
    
    // Parse values - simplified parsing
    static char values[MAX_OPS][2][MAX_LEN];
    int valCounts[MAX_OPS] = {0};
    
    char* valsStr = valsLine + 1; // Skip [
    valsStr[strlen(valsStr) - 1] = '\0'; // Remove ]
    
    int i = 0, valIdx = 0;
    while (i < strlen(valsStr) && valIdx < opCount) {
        if (valsStr[i] == '[') {
            int j = i + 1;
            int count = 1;
            while (count > 0 && j < strlen(valsStr)) {
                if (valsStr[j] == '[') count++;
                else if (valsStr[j] == ']') count--;
                j++;
            }
            
            char sub[200];
            strncpy(sub, valsStr + i + 1, j - i - 2);
            sub[j - i - 2] = '\0';
            
            if (strlen(sub) > 0) {
                char* subToken = strtok(sub, ",");
                int subIdx = 0;
                while (subToken != NULL && subIdx < 2) {
                    trim(subToken);
                    removeQuotes(subToken);
                    strcpy(values[valIdx][subIdx], subToken);
                    subIdx++;
                    subToken = strtok(NULL, ",");
                }
                valCounts[valIdx] = subIdx;
            }
            
            valIdx++;
            i = j;
            while (i < strlen(valsStr) && valsStr[i] == ',') i++;
        } else {
            i++;
        }
    }
    
    // Execute operations
    MapSum* obj = NULL;
    printf("[");
    
    for (int i = 0; i < opCount; i++) {
        if (i > 0) printf(",");
        
        if (strcmp(operations[i], "MapSum") == 0) {
            obj = mapSumCreate();
            printf("null");
        } else if (strcmp(operations[i], "insert") == 0) {
            mapSumInsert(obj, values[i][0], atoi(values[i][1]));
            printf("null");
        } else if (strcmp(operations[i], "sum") == 0) {
            printf("%d", mapSumSum(obj, values[i][0]));
        }
    }
    
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

30.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