Maximum number of envelopes that can be put inside other bigger envelopes

• Difficulty Level : Expert
• Last Updated : 14 Jun, 2021

Given N number of envelopes, as {W, H} pair, where W as the width and H as the height. One envelope can fit into another if and only if both the width and height of one envelope is greater than the width and height of the other envelope. Find the maximum number of envelopes that can be put inside another envelope and so on. Rotation of envelope is not allowed.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Examples:

Input: envelope[] = {{4, 3}, {5, 3}, {5, 6}, {1, 2}}
Output: 3
Explanation:
The maximum number of envelopes that can be put into another envelope
is 3.
({1, 2}, {4, 3}, {5, 6})

Input: envelope[] = {{3, 6}, {5, 4}, {4, 8}, {6, 9}, {10, 7}, {12, 12}}
Output: 4
Explanation:
The maximum number of envelopes that can be put into another envelope is 4.
({3, 6}, {4, 8}, {6, 9}, {12, 12})

Naive Approach: This problem is similar to the Longest Increasing Subsequence problem of Dynamic Programming. The idea is to sort the envelopes in non-decreasing order and for each envelope check the number of envelopes that can be put inside that envelope. Follow the steps below to solve the problem:

• Sort the array in the non-decreasing order of width and height.
• Initialize a dp[] array, where dp[i] stores the number of envelopes that can be put inside with envelope[i] as the largest envelope.
• For each envelope[i], loop through the envelopes smaller than itself and check if the width and the height of the smaller envelope is strictly less than that of envelope[i]. If it is less, than the smaller envelope can be put inside envelope[i].
• The maximum of the dp[] array gives the maximum number of envelopes that can be put inside one another.

Below is the implementation of the above approach:

C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function that returns the maximum` `// number of envelopes that can be` `// inserted into another envelopes` `int` `maxEnvelopes(vector > envelopes)` `{` `    ``// Number of envelopes` `    ``int` `N = envelopes.size();`   `    ``if` `(N == 0)` `        ``return` `N;`   `    ``// Sort the envelopes in` `    ``// non-decreasing order` `    ``sort(envelopes.begin(),` `        ``envelopes.end());`   `    ``// Initialize dp[] array` `    ``int` `dp[N];`   `    ``// To store the result` `    ``int` `max_envelope = 1;`   `    ``dp[0] = 1;`   `    ``// Loop through the array` `    ``for` `(``int` `i = 1; i < N; ++i) {` `        ``dp[i] = 1;`   `        ``// Find envelopes count for` `        ``// each envelope` `        ``for` `(``int` `j = 0; j < i; ++j) {`   `            ``if` `(envelopes[i][0] > envelopes[j][0]` `                ``&& envelopes[i][1] > envelopes[j][1]` `                ``&& dp[i] < dp[j] + 1)` `                ``dp[i] = dp[j] + 1;` `        ``}`   `        ``// Store maximum envelopes count` `        ``max_envelope = max(max_envelope,` `                        ``dp[i]);` `    ``}`   `    ``// Return the result` `    ``return` `max_envelope;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given the envelopes` `    ``vector > envelopes` `        ``= { { 4, 3 }, { 5, 3 }, { 5, 6 }, { 1, 2 } };`   `    ``// Function Call` `    ``cout << maxEnvelopes(envelopes);`   `    ``return` `0;` `}`

Java

 `// Java program for the above approach` `import` `java.util.*;` `import` `java.lang.*;`   `class` `GFG{` `    `  `// Function that returns the maximum` `// number of envelopes that can be` `// inserted into another envelopes` `static` `int` `maxEnvelopes(``int``[][] envelopes)` `{` `    `  `    ``// Number of envelopes` `    ``int` `N = envelopes.length;` `    `  `    ``if` `(N == ``0``)` `        ``return` `N;` `    `  `    ``// Sort the envelopes in` `    ``// non-decreasing order` `    ``Arrays.sort(envelopes,` `               ``(a, b) -> (a[``0``] != b[``0``]) ? ` `                          ``a[``0``] - b[``0``] :` `                          ``a[``1``] - b[``1``]);` `                          `  `    ``// Initialize dp[] array` `    ``int``[] dp = ``new` `int``[N];` `    `  `    ``// To store the result` `    ``int` `max_envelope = ``1``;` `    `  `    ``dp[``0``] = ``1``;` `    `  `    ``// Loop through the array` `    ``for``(``int` `i = ``1``; i < N; ++i)` `    ``{` `        ``dp[i] = ``1``;` `        `  `        ``// Find envelopes count for` `        ``// each envelope` `        ``for``(``int` `j = ``0``; j < i; ++j) ` `        ``{` `            `  `            ``if` `(envelopes[i][``0``] > envelopes[j][``0``] &&` `                ``envelopes[i][``1``] > envelopes[j][``1``] &&` `                          ``dp[i] < dp[j] + ``1``)` `                ``dp[i] = dp[j] + ``1``;` `        ``}` `        `  `        ``// Store maximum envelopes count` `        ``max_envelope = Math.max(max_envelope, dp[i]);` `    ``}` `    `  `    ``// Return the result` `    ``return` `max_envelope;` `}`   `// Driver Code` `public` `static` `void` `main (String[] args)` `{` `    `  `    ``// Given the envelopes` `    ``int``[][] envelopes = { { ``4``, ``3` `}, { ``5``, ``3` `}, ` `                          ``{ ``5``, ``6` `}, { ``1``, ``2` `} };` `    `  `    ``// Function call` `    ``System.out.println(maxEnvelopes(envelopes));` `}` `}`   `// This code is contributed by offbeat`

Python3

 `# Python3 program for the above approach`   `# Function that returns the maximum` `# number of envelopes that can be` `# inserted into another envelopes` `def` `maxEnvelopes(envelopes):`   `    ``# Number of envelopes` `    ``N ``=` `len``(envelopes)`   `    ``if` `(N ``=``=` `0``):` `        ``return` `N`   `    ``# Sort the envelopes in` `    ``# non-decreasing order` `    ``envelopes ``=` `sorted``(envelopes)`   `    ``# Initialize dp[] array` `    ``dp ``=` `[``0``] ``*` `N`   `    ``# To store the result` `    ``max_envelope ``=` `1`   `    ``dp[``0``] ``=` `1`   `    ``# Loop through the array` `    ``for` `i ``in` `range``(``1``, N):` `        ``dp[i] ``=` `1`   `        ``# Find envelopes count for` `        ``# each envelope` `        ``for` `j ``in` `range``(i):`   `            ``if` `(envelopes[i][``0``] > envelopes[j][``0``]` `                ``and` `envelopes[i][``1``] > envelopes[j][``1``]` `                ``and` `dp[i] < dp[j] ``+` `1``):` `                ``dp[i] ``=` `dp[j] ``+` `1`   `        ``# Store maximum envelopes count` `        ``max_envelope ``=` `max``(max_envelope, dp[i])`   `    ``# Return the result` `    ``return` `max_envelope`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``# Given the envelopes` `    ``envelopes ``=` `[ [ ``4``, ``3` `], [ ``5``, ``3` `], ` `                ``[ ``5``, ``6` `], [ ``1``, ``2` `] ]`   `    ``# Function Call` `    ``print``(maxEnvelopes(envelopes))`   `# This code is contributed by Mohit Kumar`

Javascript

 ``

Output:

`3`

Time Complexity: O(N2)
Auxiliary Space: O(N)

Efficient Approach:To optimize the naive approach the idea is to use the concept of Binary Search and Longest Increasing Subsequence. Sorting the envelopes in the increasing order of width and the decreasing order of height if width is same, reduces the problem to finding the longest increasing sequence of height of the envelope. This approach works as width is already sorted in increasing order and only maximum increasing sequence of height is sufficient to find the maximum number of envelopes. The efficient way to find the Longest Increasing Sequence in N×log(N) approach is discussed in this article.

Below is the implementation of the above approach:

C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function that returns the maximum` `// number of envelopes that can be` `// inserted into another envelopes` `int` `maxEnvelopes(vector >& envelopes)` `{` `    ``// Number of envelopes` `    ``int` `N = envelopes.size();`   `    ``if` `(N == 0)` `        ``return` `N;`   `    ``// Sort the envelopes in increasing` `    ``// order of width and decreasing order` `    ``// of height is width is same` `    ``sort(envelopes.begin(), envelopes.end(),` `        ``[](vector<``int``>& a, vector<``int``>& b) {` `            ``return` `a[0] < b[0]` `                    ``or (a[0] == b[0] and a[1] > b[1]);` `        ``});`   `    ``// To store the longest increasing` `    ``// sequence of height` `    ``vector<``int``> dp;`   `    ``// Finding LIS of the heights` `    ``// of the envelopes` `    ``for` `(``int` `i = 0; i < N; ++i) {` `        ``auto` `iter = lower_bound(dp.begin(),` `                                ``dp.end(),` `                                ``envelopes[i][1]);`   `        ``if` `(iter == dp.end())` `            ``dp.push_back(envelopes[i][1]);` `        ``else` `if` `(envelopes[i][1] < *iter)` `            ``*iter = envelopes[i][1];` `    ``}`   `    ``// Return the result` `    ``return` `dp.size();` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given the envelopes` `    ``vector > envelopes` `        ``= { { 4, 3 }, { 5, 3 }, { 5, 6 }, { 1, 2 } };`   `    ``// Function Call` `    ``cout << maxEnvelopes(envelopes);` `    ``return` `0;` `}`

Output:

`3`

Time Complexity: O(N*log(N))
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :