Russian Doll Envelopes

Russian Doll Envelopes - Problem

You are given a 2D array of integers envelopes where envelopes[i] = [wi, hi] represents the width and height of an envelope.

One envelope can fit into another if and only if both the width and height of one envelope are greater than the other envelope's width and height.

Return the maximum number of envelopes you can Russian doll (i.e., put one inside the other).

Note: You cannot rotate an envelope.

Input & Output

Example 1 — Basic Nesting

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

› Output: 3

💡 Note: Maximum nesting: [2,3] → [5,4] → [6,7]. Each envelope fits inside the next: (2<5 and 3<4), then (5<6 and 4<7).

Example 2 — Single Envelope

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

› Output: 1

💡 Note: Only one envelope available, so maximum nesting is 1.

Example 3 — No Valid Nesting

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

› Output: 3

💡 Note: Best nesting: [1,1] → [2,3] → [4,5] or [1,1] → [2,3] → [6,7]. Can't nest [4,5] and [4,6] together since widths are equal.

Constraints

1 ≤ envelopes.length ≤ 10⁵
envelopes[i].length == 2
1 ≤ w_i, h_i ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Facebook 12

The key insight is to sort by width and transform into a Longest Increasing Subsequence problem on heights. The optimal approach uses binary search for O(n log n) complexity. Time: O(n log n), Space: O(n).

Common Approaches

✓ Brute Force with Recursion

⏱️ Time: O(2^n) Space: O(n)

For each envelope, recursively try to fit all possible smaller envelopes inside it. Check every combination to find the maximum depth of nesting possible.

Sort + Binary Search LIS

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

After sorting envelopes by width, use binary search to efficiently find the longest increasing subsequence on heights. This reduces the LIS computation from O(n²) to O(n log n).

Sort + Dynamic Programming

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

Sort envelopes by width (and height descending for same width). Then find the longest increasing subsequence based on heights, which gives us the maximum nesting.

Brute Force with Recursion — Algorithm Steps

Try each envelope as starting point
For each envelope, recursively find all that can fit inside
Return maximum depth found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Each Envelope

Start with each envelope as potential beginning

Recursive Search

For each choice, recursively find all valid nestings

Maximum Depth

Return the deepest nesting found

Code -

solution.c — C

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

static int envelopes[1000][2];
static int used[1000];
static int n;

int canFit(int* env1, int* env2) {
    return env1[0] < env2[0] && env1[1] < env2[1];
}

int max(int a, int b) {
    return a > b ? a : b;
}

int dfs(int currentChain[][2], int chainLen) {
    int maxLen = chainLen;
    
    // Try to extend the chain with any unused envelope
    for (int i = 0; i < n; i++) {
        if (!used[i]) {
            // Check if this envelope can extend our current chain
            if (chainLen == 0 || canFit(currentChain[chainLen-1], envelopes[i])) {
                used[i] = 1;
                currentChain[chainLen][0] = envelopes[i][0];
                currentChain[chainLen][1] = envelopes[i][1];
                maxLen = max(maxLen, dfs(currentChain, chainLen + 1));
                used[i] = 0;
            }
        }
    }
    
    return maxLen;
}

int solution() {
    memset(used, 0, sizeof(used));
    int currentChain[1000][2];
    return dfs(currentChain, 0);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    n = 0;
    
    char* ptr = line + 1;
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            envelopes[n][0] = strtol(ptr, &ptr, 10);
            ptr++;
            envelopes[n][1] = strtol(ptr, &ptr, 10);
            n++;
        }
        ptr++;
    }
    
    printf("%d\n", solution());
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

For each envelope we try two choices: include or exclude, leading to exponential combinations

⚡ Linearithmic

Space Complexity

O(n)

Recursion depth can go up to n envelopes

⚡ Linearithmic Space

125.0K Views

Medium Frequency

~35 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler