# Find maximum height pyramid from the given array of objects

Given n objects, with each object has width wi. We need to arrange them in a pyramidal way such that :

1. Total width of ith is less than (i + 1)th.
2. Total number of objects in the ith is less than (i + 1)th.

The task is to find the maximum height that can be achieved from given objects.

Examples:

```Input : arr[] = {40, 100, 20, 30}
Output : 2
Top level : 30.
Lower (or bottom) level : 20, 40 and 100
Other possibility can be placing
20 on the top, and at second level any
other 4 objects. Another possibility is
to place 40 at top and other three at the
bottom.

Input : arr[] = {10, 20, 30, 50, 60, 70}
Output : 3
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

The idea is to use greedy approach by placing the object with the lowest width at the top, the next object at the level right below and so on.
To find the maximum number of levels, sort the given array and try to form pyramid from top to bottom. Find the smallest element of array i.e first element of array after sorting, place it on the top. Then try to build levels below it with greater number of objects and greater width.

Below is C++ implementation of this approach:

```// C++ program to find maximum height pyramid
// from the given object width.
#include<bits/stdc++.h>
using namespace std;

// Returns maximum number of pyramidcal levels
// n boxes of given widths.
int maxLevel(int boxes[], int n)
{
// Sort objects in increasing order of widths
sort(boxes, boxes + n);

int ans = 1;  // Initialize result

// Total width of previous level and total
// number of objects in previous level
int prev_width = boxes[0];
int prev_count = 1;

// Number of object in current level.
int curr_count = 0;

// Width of current level.
int curr_width = 0;
for (int i=1; i<n; i++)
{
// Picking the object. So increase current
// width and number of object.
curr_width += boxes[i];
curr_count += 1;

// If current width and number of object
// are greater than previous.
if (curr_width > prev_width &&
curr_count > prev_count)
{
// Update previous width, number of
// object on previous level.
prev_width = curr_width;
prev_count = curr_count;

// Reset width of current level, number
// of object on current level.
curr_count = 0;
curr_width = 0;

// Increment number of level.
ans++;
}
}

return ans;
}

// Driver Program
int main()
{
int boxes[] = {10, 20, 30, 50, 60, 70};
int n = sizeof(boxes)/sizeof(boxes[0]);
cout << maxLevel(boxes, n) << endl;
return 0;
}
```

Output:

```3
```

Time Complexity: O(n log n).

This article is contributed by Anuj Chauhan. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
2.4 Average Difficulty : 2.4/5.0
Based on 5 vote(s)