Russian Doll Envelopes - Practice Coding Problems

Russian Doll Envelopes - Problem

Imagine you have a collection of envelopes and you want to nest them inside each other like Russian dolls! 🎎

You are given a 2D array envelopes where envelopes[i] = [width, height] represents the dimensions of each envelope. An envelope can fit inside another envelope if and only if both its width and height are strictly smaller than the outer envelope.

Your goal: Find the maximum number of envelopes you can nest inside each other. Note that you cannot rotate the envelopes - they must maintain their original orientation.

Example: Given envelopes [[5,4],[6,4],[6,7],[2,3]], you can nest them as: [2,3] → [5,4] → [6,7] for a maximum of 3 envelopes.

Input & Output

example_1.py — Basic Case

$ Input: envelopes = [[5,4],[6,4],[6,7],[2,3]]

› Output: 3

💡 Note: The maximum number of envelopes you can Russian doll is 3: [2,3] → [5,4] → [6,7]. Note that [6,4] cannot be used because it has the same width as [6,7].

example_2.py — Single Envelope

$ Input: envelopes = [[1,1]]

› Output: 1

💡 Note: With only one envelope, the maximum nesting is 1 (the envelope itself).

example_3.py — No Nesting Possible

$ Input: envelopes = [[4,5],[4,6],[6,7],[2,3],[1,1]]

› Output: 4

💡 Note: The optimal nesting is [1,1] → [2,3] → [4,5] → [6,7] for a maximum of 4 envelopes.

Visualization

Tap to expand

Understanding the Visualization

Start with Unsorted Envelopes

Given envelopes with different dimensions [[5,4],[6,4],[6,7],[2,3]]

Smart Sorting Strategy

Sort by width↑, height↓ for same width: [[2,3],[5,4],[6,7],[6,4]]

Extract Heights for LIS

Create 1D problem: heights = [3,4,7,4], find LIS

Binary Search Optimization

Use binary search to efficiently build LIS: length = 3

Key Takeaway

🎯 Key Insight: Transform the 2D envelope problem into 1D Longest Increasing Subsequence by sorting smartly, then use binary search for optimal O(n log n) performance!

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n log n) for LIS with binary search

⚡ Linearithmic

Space Complexity

O(n)

Array to store the LIS sequence

⚡ Linearithmic Space

Constraints

1 ≤ envelopes.length ≤ 10⁵
envelopes[i].length == 2
1 ≤ width_i, height_i ≤ 10⁵
Cannot rotate envelopes - must maintain original orientation

Asked in

G Google 42 a Amazon 38 f Facebook 29 ⊞ Microsoft 25 Apple 18

The optimal solution uses a clever sorting strategy combined with binary search to achieve O(n log n) complexity. Sort envelopes by width ascending and height descending for same width, then find the Longest Increasing Subsequence of heights using binary search optimization.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Binary Search (Optimal)	O(n log n)	O(n)	Sort by width, then use LIS with binary search on heights for O(n log n) complexity
Dynamic Programming (Brute Force)	O(n²)	O(n)	Use O(n²) dynamic programming to check all pairs of envelopes

Sorting + Binary Search (Optimal) — Algorithm Steps

Sort envelopes by width ascending, height descending for same width
Extract heights array from sorted envelopes
Use binary search to find LIS of heights
For each height, find position to insert/replace in LIS array
Return length of final LIS array

Visualization

Tap to expand

Step-by-Step Walkthrough

Smart Sorting

Sort by width↑, height↓ for same width

Extract Heights

Create 1D array of heights from sorted envelopes

Binary Search LIS

Use binary search to efficiently find LIS

Maintain Tails Array

Keep track of smallest tail for each length

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    int *arr1 = *(int**)a;
    int *arr2 = *(int**)b;
    if (arr1[0] == arr2[0]) {
        return arr2[1] - arr1[1]; // descending height for same width
    }
    return arr1[0] - arr2[0];
}

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

int lengthOfLIS(int* nums, int size) {
    int* tails = (int*)malloc(size * sizeof(int));
    int tailsSize = 0;
    
    for (int i = 0; i < size; 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 maxEnvelopes(int** envelopes, int envelopesSize, int* envelopesColSize) {
    if (envelopesSize == 0) return 0;
    
    // Sort envelopes
    qsort(envelopes, envelopesSize, sizeof(int*), compare);
    
    // Extract heights
    int* heights = (int*)malloc(envelopesSize * sizeof(int));
    for (int i = 0; i < envelopesSize; i++) {
        heights[i] = envelopes[i][1];
    }
    
    int result = lengthOfLIS(heights, envelopesSize);
    free(heights);
    return result;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n log n) for LIS with binary search

⚡ Linearithmic

Space Complexity

O(n)

Array to store the LIS sequence

⚡ Linearithmic Space

Constraints

1 ≤ envelopes.length ≤ 10⁵
envelopes[i].length == 2
1 ≤ width_i, height_i ≤ 10⁵
Cannot rotate envelopes - must maintain original orientation

82.5K Views

Medium-High Frequency

~25 min Avg. Time

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

Sorting + Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler