Longest Increasing Subsequence II

Longest Increasing Subsequence II - Problem

Array Divide and Conquer Dynamic Programming Binary Indexed Tree Segment Tree Queue Monotonic Queue Hard

You are given an integer array nums and an integer k. Your task is to find the longest subsequence that satisfies two important conditions:

The subsequence is strictly increasing
The difference between any two adjacent elements in the subsequence is at most k

A subsequence is derived from the original array by deleting some or no elements without changing the order of the remaining elements. For example, from array [4,2,1,4,3,4,5,8,15], a valid subsequence could be [2,4,5,8].

Return the length of the longest subsequence that meets both requirements.

Example: If nums = [4,2,1,4,3,4,5,8,15] and k = 3, one possible longest increasing subsequence with difference ≤ 3 could be [1,3,4,5,8] with length 5.

Input & Output

example_1.py — Basic Case

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

› Output: 5

💡 Note: One possible longest increasing subsequence is [1,3,4,5,8] with length 5. Each adjacent pair has difference ≤ 3: 3-1=2, 4-3=1, 5-4=1, 8-5=3.

example_2.py — Small Difference

$ Input: nums = [7,4,5,1,8,12,4,7], k = 5

› Output: 4

💡 Note: One possible longest increasing subsequence is [4,5,7,12] with length 4. Differences: 5-4=1, 7-5=2, 12-7=5 (all ≤ 5).

example_3.py — Edge Case

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

› Output: 1

💡 Note: Cannot form increasing subsequence of length > 1 because 5-1=4 > k=1. Maximum length is 1.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i], k ≤ 10⁵
The array can contain duplicate values
Subsequence must be strictly increasing (no equal elements)

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses coordinate compression with a segment tree to achieve O(n log n) time complexity. The key insight is to avoid checking all previous elements by using a data structure that can efficiently find the maximum subsequence length in a range of values that satisfy the constraint |nums[i] - nums[j]| ≤ k.

Common Approaches

✓ Optimized

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

Sort First

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

Brute Force Dynamic Programming

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

Use dynamic programming where dp[i] represents the length of the longest increasing subsequence ending at index i. For each element, check all previous elements to see if they can form a valid subsequence.

Segment Tree / Binary Indexed Tree

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

Coordinate compression with segment tree approach. Compress all values to a smaller range, then use a segment tree to efficiently find the maximum subsequence length in any range and update values.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* nums, int size) {
    int operations = 0;
    int start = 0, end = size - 1;
    int* temp = (int*)malloc(size * sizeof(int));
    
    while (start <= end) {
        int minVal = nums[start];
        for (int i = start; i <= end; i++) {
            if (nums[i] < minVal) minVal = nums[i];
        }
        
        if (nums[start] == minVal) {
            start++;
        } else {
            int tempSize = 0;
            for (int i = start + 1; i <= end; i++) {
                temp[tempSize++] = nums[i];
            }
            temp[tempSize++] = nums[start];
            for (int i = 0; i < tempSize; i++) {
                nums[start + i] = temp[i];
            }
        }
        operations++;
    }
    
    free(temp);
    return operations;
}

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

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

~35 min Avg. Time

892 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