Longest Increasing Subsequence - Practice Coding Problems

Longest Increasing Subsequence - Problem

Given an integer array nums, you need to find the length of the longest strictly increasing subsequence.

A subsequence is a sequence that can be derived from the original array by deleting some or no elements without changing the order of the remaining elements. For example, [3,6,2,7] is a subsequence of [0,3,1,6,2,2,7].

An increasing subsequence means each element is strictly greater than the previous one. Your goal is to find the maximum possible length of such a subsequence.

Example: In array [10,9,2,5,3,7,101,18], one possible longest increasing subsequence is [2,3,7,18] with length 4.

Input & Output

example_1.py — Basic Case

$ Input: [10,9,2,5,3,7,101,18]

› Output: 4

💡 Note: The longest increasing subsequence is [2,3,7,101] or [2,3,7,18], both have length 4. There are multiple valid subsequences of the same maximum length.

example_2.py — All Decreasing

$ Input: [7,7,7,7,7,7,7]

› Output: 1

💡 Note: All elements are equal, so the longest strictly increasing subsequence has length 1 (any single element).

example_3.py — Already Sorted

$ Input: [1,3,6,7,9,4,10,5,6]

› Output: 6

💡 Note: The longest increasing subsequence is [1,3,4,5,6] or [1,3,6,7,9,10], both with length 6. We can pick elements in any order as long as they maintain increasing property.

Visualization

Tap to expand

Understanding the Visualization

Start with First Block

Place the first block as the foundation of your staircase

Process Each Block

For each new block, decide whether to start a new staircase or extend an existing one

Make Optimal Choice

Always keep the smallest possible 'top block' for each staircase height to maximize future options

Find Maximum Height

The height of your tallest staircase is the answer

Key Takeaway

🎯 Key Insight: By maintaining the smallest tail for each possible length, we create maximum opportunities for future extensions while using binary search for efficiency.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

For each of n elements, we perform binary search on tails array which can be at most n elements long

⚡ Linearithmic

Space Complexity

O(n)

Additional tails array that stores at most n elements in worst case

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 2500
-10⁴ ≤ nums[i] ≤ 10⁴
Follow up: Can you come up with an O(n log n) solution?

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28 Apple 22

The optimal solution uses a greedy approach with binary search achieving O(n log n) time complexity. We maintain a 'tails' array where tails[i] represents the smallest tail element of all increasing subsequences of length i+1. For each new element, we use binary search to find its correct position, either extending the longest subsequence or replacing an existing tail to keep it minimal.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search + Greedy (Optimal)	O(n log n)	O(n)	Maintain array of smallest tail elements for each length, use binary search to find position
Dynamic Programming (Nested Loops)	O(n²)	O(n)	For each element, check all previous elements to build the longest sequence ending at current position

Binary Search + Greedy (Optimal) — Algorithm Steps

Initialize empty 'tails' array to store smallest tail for each length
For each element in nums, use binary search to find position in tails
If element is larger than all tails, append to extend longest subsequence
Otherwise, replace the tail at found position to keep it minimal
Return length of tails array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Tails

Start with empty tails array

Process Each Element

Use binary search to find correct position in tails array

Update Tails

Either append new element or replace existing to keep tails minimal

Return Length

Length of tails array is the answer

Code -

solution.c — C

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

int binarySearch(int* tails, int size, int target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (tails[mid] < target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

int lengthOfLIS(int* nums, int numsSize) {
    if (numsSize == 0) return 0;
    
    int* tails = (int*)malloc(numsSize * sizeof(int));
    int tailsSize = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int pos = binarySearch(tails, tailsSize, nums[i]);
        
        if (pos == tailsSize) {
            tails[tailsSize++] = nums[i];
        } else {
            tails[pos] = nums[i];
        }
    }
    
    int result = tailsSize;
    free(tails);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

For each of n elements, we perform binary search on tails array which can be at most n elements long

⚡ Linearithmic

Space Complexity

O(n)

Additional tails array that stores at most n elements in worst case

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 2500
-10⁴ ≤ nums[i] ≤ 10⁴
Follow up: Can you come up with an O(n log n) solution?

48.8K Views

High Frequency

~25 min Avg. Time

1.5K 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

Binary Search + Greedy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler