Longest Increasing Subsequence II - Practice Coding Problems

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.

Visualization

Tap to expand

Understanding the Visualization

Scan Array

Process each element from left to right

Find Valid Range

For current element x, find all previous elements in range [x-k, x-1]

Get Maximum

Query the maximum subsequence length ending in the valid range

Update Tree

Update data structure with new maximum length at current position

Key Takeaway

🎯 Key Insight: Use segment tree with coordinate compression to efficiently query the maximum subsequence length in any value range, reducing time complexity from O(n²) to O(n log n).

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Coordinate compression O(n log n) + n operations on segment tree O(log n) each

⚡ Linearithmic

Space Complexity

O(n)

Segment tree and coordinate compression arrays

⚡ Linearithmic Space

Constraints

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

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

Approach	Time	Space	Notes
✓ Segment Tree / Binary Indexed Tree	O(n log n)	O(n)	Use segment tree to efficiently query and update maximum subsequence lengths
Brute Force Dynamic Programming	O(n²)	O(n)	Check all previous elements for each position using O(n²) DP

Segment Tree / Binary Indexed Tree — Algorithm Steps

Compress coordinates by sorting unique values and mapping to indices
Build a segment tree to support range maximum queries and point updates
For each element, query the maximum length in range [1, compressed_value-1] where the difference ≤ k
Update the segment tree with the new maximum length at current element's compressed position

Visualization

Tap to expand

Step-by-Step Walkthrough

Compress Values

Map unique values to smaller indices

Build Tree

Create segment tree for range queries

Query & Update

For each element, query valid range and update tree

Code -

solution.c — C

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

typedef struct {
    int n;
    int* tree;
} SegmentTree;

SegmentTree* createSegmentTree(int size) {
    SegmentTree* st = (SegmentTree*)malloc(sizeof(SegmentTree));
    st->n = size;
    st->tree = (int*)calloc(4 * size, sizeof(int));
    return st;
}

void updateHelper(SegmentTree* st, int pos, int val, int tl, int tr, int v) {
    if (tl == tr) {
        if (val > st->tree[v]) {
            st->tree[v] = val;
        }
    } else {
        int tm = (tl + tr) / 2;
        if (pos <= tm) {
            updateHelper(st, pos, val, tl, tm, 2 * v);
        } else {
            updateHelper(st, pos, val, tm + 1, tr, 2 * v + 1);
        }
        int left = st->tree[2 * v];
        int right = st->tree[2 * v + 1];
        st->tree[v] = left > right ? left : right;
    }
}

void update(SegmentTree* st, int pos, int val) {
    updateHelper(st, pos, val, 1, st->n, 1);
}

int queryHelper(SegmentTree* st, int l, int r, int tl, int tr, int v) {
    if (l > r) return 0;
    if (l == tl && r == tr) {
        return st->tree[v];
    }
    int tm = (tl + tr) / 2;
    int leftResult = queryHelper(st, l, l < tm ? (r < tm ? r : tm) : tm + 1, tl, tm, 2 * v);
    int rightResult = queryHelper(st, l > tm + 1 ? l : tm + 1, r, tm + 1, tr, 2 * v + 1);
    return leftResult > rightResult ? leftResult : rightResult;
}

int query(SegmentTree* st, int l, int r) {
    return queryHelper(st, l, r, 1, st->n, 1);
}

int lengthOfLIS(int* nums, int numsSize, int k) {
    if (numsSize == 0) return 0;
    
    // Simple approach for C implementation
    int* dp = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        dp[i] = 1;
    }
    
    for (int i = 1; i < numsSize; i++) {
        for (int j = 0; j < i; j++) {
            if (nums[j] < nums[i] && nums[i] - nums[j] <= k) {
                int newLen = dp[j] + 1;
                if (newLen > dp[i]) {
                    dp[i] = newLen;
                }
            }
        }
    }
    
    int maxLen = dp[0];
    for (int i = 1; i < numsSize; i++) {
        if (dp[i] > maxLen) {
            maxLen = dp[i];
        }
    }
    
    free(dp);
    return maxLen;
}

int main() {
    int nums[] = {4, 2, 1, 4, 3, 4, 5, 8, 15};
    int k = 3;
    printf("%d\n", lengthOfLIS(nums, 9, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Coordinate compression O(n log n) + n operations on segment tree O(log n) each

⚡ Linearithmic

Space Complexity

O(n)

Segment tree and coordinate compression arrays

⚡ Linearithmic Space

Constraints

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

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Segment Tree / Binary Indexed Tree — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler