Ninja And Stack Of Boxes
Ninja has been given ‘N’ rectangular 3-D ‘BOXES’. Each box has dimensions Length ‘L’, Breadth ‘B’ and Height ‘H’. Ninja has to create a stack of boxes as tall as possible. But there is a condition to do so.

You can only place a box on top of another box only if the dimensions of the 2-D base of the lower box are each strictly larger than those of the 2-D base of the higher box. You can rotate any box so that any side of the box is used as a base. You can take multiple instances of any box.

Can you help the Ninja to create a stack of boxes as tall as possible?.

Input Format :

The first line of input contains an integer ‘T’ which denotes the number of test cases or queries to be run. Then the test cases follow. The first line of each test case contains a space-separated integer ‘N’, which represents the number of boxes. The next ‘N’ lines of each test case contain three space-separated integers ‘L’, ‘B’, and ’H’ that represent the length, breadth, and height of a box.

Output Format :

For each test case, print the maximum height of the stack which can be made using these boxes. Print the output of each test case in a separate line.

Note :

You do not need to print anything; it has already been taken care of. Just implement the given function.

Constraints :

1

Question

Ninja And Stack Of Boxes

Ninja has been given ‘N’ rectangular 3-D ‘BOXES’. Each box has dimensions Length ‘L’, Breadth ‘B’ and Height ‘H’. Ninja has to create a stack of boxes as tall as possible. But there is a condition to do so.

You can only place a box on top of another box only if the dimensions of the 2-D base of the lower box are each strictly larger than those of the 2-D base of the higher box. You can rotate any box so that any side of the box is used as a base. You can take multiple instances of any box.

Can you help the Ninja to create a stack of boxes as tall as possible?.

Input Format :

The first line of input contains an integer ‘T’ which denotes the number of test cases or queries to be run. Then the test cases follow.

The first line of each test case contains a space-separated integer ‘N’, which represents the number of boxes.

The next ‘N’ lines of each test case contain three space-separated integers ‘L’, ‘B’, and ’H’ that represent the length, breadth, and height of a box.

Output Format :

For each test case, print the maximum height of the stack which can be made using these boxes.

Print the output of each test case in a separate line.

Note :

You do not need to print anything; it has already been taken care of. Just implement the given function.

Constraints :

1 <= ‘T’ <= 100
1 <= ‘N’ <= 5000
1 <= ‘L’, ‘B’, ‘H’ <= 100000 

Time Limit: 1 second

Accepted Answer

Recursive

As we know we can place a box upon another box if the base area is smaller than the previously selected box. So, first of all, we sort the boxes according to the base area. Then we traverse through all the boxes and assume that the ‘i’th’ box is placed at the bottom. Then we try to place all the remaining boxes on this ‘i’th’ box and calculate the maximum height of the stack.

Algorithm:

We declare a list/vector ‘BOXES’ in which we store every possible rotation of all the boxes.
Sort ‘BOXES’ according to the base area.
We declare a variable ‘maxHeight’ in which we store the maximum height of the stack.
We run a loop for ‘i’ = 0 to ‘BOXES.size()’
- ‘maxHeight’ = Math.max(‘maxHeight’, ‘ninjaAndStackOfBoxesHelper(‘BOXES’ , ‘i’)’)
Finally, return the ‘maxHeight’.

ninjaAndStackOfBoxesHelper(‘BOXES’, ‘i’) function is explained below:

We declare a variable ‘currMaxHeight’ and initialize it with 0.
We run a loop for while ‘j’ = ‘i’ + 1 to ‘BOXES.size()’
- If ‘BOXES[i].breadth < ‘BOXES[j].breadth’ and ‘BOXES[i].length’ < ‘BOXES[j].length’
  - ‘currMaxHeight’ = max(‘currMaxHeight’, ninjaAndStackOfBoxesHelper(‘BOXES’, ‘ j’)).
‘currMaxHeight’ += ‘BOXES.height’.
Return ‘currMaxHeight’.

Space Complexity: O(n)Explanation:

O(N) where ‘N’ is the number of boxes.

O(N) recursion stack is used by the recursive function. We are also using the ‘BOXES’ array/list in which we store every possible rotation of all the boxes.

So the overall space complexity is O(N).

Time Complexity: O(n^n)Explanation:

O(N ^ N) where ‘N’ is the number of boxes.

First, we are sorting the ‘BOXES’ array/list which takes O(N log(N) time. Then for finding the maximum height of the stack we are traversing the array/list ‘BOXES’ and for every box, we are calling our recursive function.

Hence the overall time complexity is O(N ^ N).

Accepted Answer

Memoization

We can also optimize our previous approach. There are a lot of overlapping subproblems so we can use an array/vector ‘MEMO’ where ‘MEMO[i]’ denotes the maximum height when the number of boxes is ‘i’. And in which we store our previous calculated result.

Algorithm:

We declare a list/vector ‘BOXES’ in which we store every possible rotation of all the boxes.
Sort ‘BOXES’ according to the base area.
We declare a variable ‘maxHeight’ in which we store the maximum height of the stack.
We declare a ‘MEMO’ array/vector in which we store our previous calculated result and initialize it with -1.
We run a loop for ‘i’ = 0 to ‘BOXES.size()’
- ‘maxHeight’ = Math.max(‘maxHeight’, ‘ninjaAndStackOfBoxesHelper(‘BOXES’ , ‘i’, ‘MEMO’)’)
Finally, return the ‘maxHeight’.

ninjaAndStackOfBoxesHelper(‘BOXES’, ‘i’, ‘MEMO’ ) function is explained below:

If ‘i’ < ‘BOXES.size()’ and ‘MEMO[i] != -1’
- Return ‘MEMO[i]’
We declare a variable ‘currMaxHeight’ and initialize it with 0.
We run a loop while ‘j’ = ‘i’ + 1 to ‘BOXES.size()’
- If ‘BOXES[i].breadth < ‘BOXES[j].breadth’ and ‘BOXES[i].length’ < ‘BOXES[j].length’
  - ‘currMaxHeight’ = max(‘currMaxHeight’, ninjaAndStackOfBoxesHelper(‘BOXES’, ‘ j’)).
‘currMaxHeight’ += ‘BOXES.height’.
‘MEMO[i]’ = ‘currMaxHeight’
Return ‘currMaxHeight’.

Space Complexity: O(n)Explanation:

O(N) where ‘N’ is the number of boxes.

O(N) recursion stack is used by the recursive function. We are also using the ‘BOXES’ array/list in which we store every possible rotation of all the boxes. We are also using a ‘MEMO’ array/list in which we store our previous calculated result.

So the overall space complexity is O(N).

Time Complexity: O(n^2)Explanation:

O(N ^ 2) where ‘N’ is the number of boxes.

First, we are sorting the ‘BOXES’ array/list which takes O(N log N) time. Then for finding the maximum height of the stack we are traversing the array/list ‘BOXES’ and for every box, we are calling our recursive function.

As there can be at most N^2 distinct recursive calls, the overall time complexity is O(N^2).

Java (SE 1.8)

/*

	Time complexity: O(N ^ 2)
	Space complexity: O(N)

	Where N is the number of boxes.

*/

import java.util.ArrayList;
import java.util.Collections;
import java.util.Arrays;

class Box implements Comparable 
{

	int l, b, h, area;

	public Box(int l, int b, int h) 
	{
		this.l = l;
		this.b = b;
		this.h = h;
		this.area = l * b;
	}

	public int compareTo(Box o) 
	{
		return this.area - o.area;
	}
}

public class Solution 
{

	public static int ninjaAndBoxStackHelper(ArrayList boxes, int bottomBoxIndex, int memo[]) 
	{
		if (bottomBoxIndex < boxes.size() && memo[bottomBoxIndex] != -1) 
		{
			return memo[bottomBoxIndex];
		}

		int currMaxHeight = 0;

		for (int j = bottomBoxIndex + 1; j < boxes.size(); j++) 
		{
			// If the box is smaller then update current maximum height.
			if (boxes.get(bottomBoxIndex).b < boxes.get(j).b && boxes.get(bottomBoxIndex).l < boxes.get(j).l) 
			{
				currMaxHeight = Math.max(currMaxHeight, ninjaAndBoxStackHelper(boxes, j, memo));
			}
		}
		currMaxHeight += boxes.get(bottomBoxIndex).h;
		memo[bottomBoxIndex] = currMaxHeight;

		return currMaxHeight;

	}

	public static int ninjaAndBoxStack(int length[], int breadth[], int height[], int n) 
	{

		ArrayList boxes = new ArrayList<>();

		for (int i = 0; i < n; i++) 
		{
			// Largest side is the length and shortest side is breadth.
			boxes.add(new Box(Math.max(length[i], breadth[i]), Math.min(length[i], breadth[i]), height[i]));
			boxes.add(new Box(Math.max(height[i], breadth[i]), Math.min(height[i], breadth[i]), length[i]));
			boxes.add(new Box(Math.max(length[i], height[i]), Math.min(length[i], height[i]), breadth[i]));
		}

		Collections.sort(boxes);

		int memo[] = new int[boxes.size()];

		Arrays.fill(memo, -1);

		int maxHeight = 0;

		for (int i = 0; i < boxes.size(); i++) 
		{
			maxHeight = Math.max(maxHeight, ninjaAndBoxStackHelper(boxes, i, memo));
		}

		return maxHeight;
	}

}

Python (3.5)

'''

    Time complexity: O(N ^ 2)
    Space complexity: O(N)

    Where N is the number of boxes.

'''

def compareTo(a, b): 
        return a[-1] < b[-1]

def ninjaAndBoxStackHelper(boxes, bottomBoxIndex, memo): 

    if (bottomBoxIndex < len(boxes) and memo[bottomBoxIndex] != -1): 
        return memo[bottomBoxIndex]

    currMaxHeight = 0

    for j in range(bottomBoxIndex + 1, len(boxes)): 

        # If the box is smaller then update current maximum height.
        if (boxes[bottomBoxIndex][1] < boxes[j][1] and boxes[bottomBoxIndex][0] < boxes[j][0]): 
            currMaxHeight = max(currMaxHeight, ninjaAndBoxStackHelper(boxes, j, memo))

    currMaxHeight += boxes[bottomBoxIndex][2]
    memo[bottomBoxIndex] = currMaxHeight

    return currMaxHeight


def ninjaAndBoxStack(length, breadth, height, n): 

    boxes=[]

    for i in range(n):

        # Largest side is the length and shortest side is breadth.
        boxes.append((max(length[i], breadth[i]), min(length[i], breadth[i]), height[i]))
        boxes.append((max(height[i], breadth[i]), min(height[i], breadth[i]), length[i]))
        boxes.append((max(length[i], height[i]), min(length[i], height[i]), breadth[i]))

    boxes = sorted(boxes, key = lambda x: x[1]*x[0])
    
    memo=[-1]*len(boxes)
    maxHeight = 0

    for i in range(len(boxes)):
        maxHeight = max(maxHeight, ninjaAndBoxStackHelper(boxes, i, memo))

    return maxHeight

C++ (g++ 5.4)

/*

    Time complexity: O(N ^ 2)
    Space complexity: O(N)

    Where N is the number of boxes.

*/


class Box 
{

public:
    int l, b, h, area;

    Box(int l, int b, int h) 
    {
        this -> l = l;
        this -> b = b;
        this -> h = h;
        this -> area = l * b;
    }
    
};

bool compareTo(Box a, Box b) 
{
        return a.area < b.area;
}

int ninjaAndBoxStackHelper(vector& boxes, int bottomBoxIndex, vector& memo) 
{
    if (bottomBoxIndex < boxes.size() && memo[bottomBoxIndex] != -1) 
    {
        return memo[bottomBoxIndex];
    }

    int currMaxHeight = 0;

    for (int j = bottomBoxIndex + 1; j < boxes.size(); j++) 
    {
        // If the box is smaller then update current maximum height.
        if (boxes[bottomBoxIndex].b < boxes[j].b && boxes[bottomBoxIndex].l < boxes[j].l) 
        {
            currMaxHeight = max(currMaxHeight, ninjaAndBoxStackHelper(boxes, j, memo));
        }
    }
    currMaxHeight += boxes[bottomBoxIndex].h;
    memo[bottomBoxIndex] = currMaxHeight;

    return currMaxHeight;

}

int ninjaAndBoxStack(vector& length, vector& breadth, vector& height, int n) 
{

    vector boxes;

    for (int i = 0; i < n; i++) 
    {
        // Largest side is the length and shortest side is breadth.
        boxes.push_back(Box(max(length[i], breadth[i]), min(length[i], breadth[i]), height[i]));
        boxes.push_back(Box(max(height[i], breadth[i]), min(height[i], breadth[i]), length[i]));
        boxes.push_back(Box(max(length[i], height[i]), min(length[i], height[i]), breadth[i]));
    }

    sort(boxes.begin(), boxes.end(), compareTo);

    vector memo(boxes.size(), -1);
    int maxHeight = 0;

    for (int i = 0; i < boxes.size(); i++) 
    {
        maxHeight = max(maxHeight, ninjaAndBoxStackHelper(boxes, i, memo));
    }

    return maxHeight;
}

Accepted Answer

Dynamic Programming

As we know we can place a box upon another box if the base area is smaller than the previously selected box. So, first of all, we sort the boxes according to the base area. Then we declare an array/vector ‘MAXI_HEIGHT’ in which we store the maximum height of the stack of boxes when the ‘i’ box is at the top of the stack of boxes. To find this we use the longest Increasing subsequence approach.

Algorithm:

We declare a list/vector ‘BOXES’ in which we store every possible rotation of all the boxes.
Sort ‘BOXES’ according to the base area.
We declare a list/vector ‘MAXI_HEIGHT’ in which we store the maximum height of the stack of boxes when the ‘i’ box is at the top of the stack of boxes.
We run a loop for ‘i’ = 0 to ‘BOXES.size()’:
- ‘MAXI_HEIGHT[i] = ‘BOXES.get(i).h’
We run a loop for ‘i’ = 0 to ‘BOXES.size()’:
- We run a loop for ‘j’ = 0 to ‘i’:
  - Then we check if we can place the ‘i’ box on top of the ‘j’ box.
  - If ‘BOXES[i].breadth < ‘BOXES[j].breadth’ and ‘BOXES[i].length’ < ‘BOXES[j].length’
    - ‘MAXI_HEIGHT[i]’ = max(‘MAXI_HEIGHT[i]’, ‘MAXI_HEIGHT[j]’ + BOXES[i].height)
Finally, we traverse on the ‘MAXI_HEIGHT’ and find the maximum height and then return the maximum height.

Space Complexity: O(n)Explanation:

O(N) where ‘N’ is the number of boxes.

We are using a ‘BOXES’ array/list in which we store every possible rotation of all the boxes. We are using ‘MAXI_HEIGHT array/list for storing the maximum height of the stack of boxes when the ‘i’ box is at the top of the stack of boxes.

So the overall space complexity is O(N).

Time Complexity: O(n^2)Explanation:

O(N ^ 2) where ‘N’ is the number of boxes.

First, we are sorting the ‘BOXES’ array/list which takes O(N log N) time. Then for finding the maximum height of the stack we are using two nested loops.

So overall time complexity is O(N ^ 2).

Java (SE 1.8)

/*

	Time complexity: O(N ^ 2)
	Space complexity: O(N)

	Where N is the number of boxes.

*/

import java.util.ArrayList;
import java.util.Collections;

class Box implements Comparable 
{

	int l, b, h, area;

	public Box(int l, int b, int h) 
	{
		this.l = l;
		this.b = b;
		this.h = h;
		this.area = l * b;
	}

	public int compareTo(Box o) 
	{
		return o.area - this.area;
	}
}

public class Solution 
{

	public static int ninjaAndBoxStack(int length[], int breadth[], int height[], int n) 
	{

		ArrayList boxes = new ArrayList<>();

		for (int i = 0; i < n; i++) 
		{
			boxes.add(new Box(Math.max(length[i], breadth[i]), Math.min(length[i], breadth[i]), height[i]));
			boxes.add(new Box(Math.max(height[i], breadth[i]), Math.min(height[i], breadth[i]), length[i]));
			boxes.add(new Box(Math.max(length[i], height[i]), Math.min(length[i], height[i]), breadth[i]));
		}

		Collections.sort(boxes);

		int maxHeight[] = new int[boxes.size()];

		for (int i = 0; i < maxHeight.length; i++) 
		{
			maxHeight[i] = boxes.get(i).h;
		}

		int maxHeightAns = 0;

		for (int i = 1; i < boxes.size(); i++) 
		{
			for (int j = 0; j < i; j++) 
			{

				// If the box is smaller then update current maximum height.
            	if (boxes.get(i).b < boxes.get(j).b && boxes.get(i).l < boxes.get(j).l) 
				{
					maxHeight[i] = Math.max(maxHeight[i], maxHeight[j] + boxes.get(i).h);
				}
			}

			maxHeightAns = Math.max(maxHeightAns, maxHeight[i]);

		}

		return maxHeightAns;
	}

}

Python (3.5)

'''

    Time complexity: O(N ^ 2)
    Space complexity: O(N)

    Where N is the number of boxes.

'''

def compareTo(a, b): 
        return a[-1]> b[-1]

def ninjaAndBoxStack(length, breadth, height, n): 

    boxes=[]

    for i in range(n):

        boxes.append((max(length[i], breadth[i]), min(length[i], breadth[i]), height[i]))
        boxes.append((max(height[i], breadth[i]), min(height[i], breadth[i]), length[i]))
        boxes.append((max(length[i], height[i]), min(length[i], height[i]), breadth[i]))

    boxes = sorted(boxes, key = lambda x: x[0]*x[1], reverse=True)

    maxHeight=[0]*len(boxes)

    for i in range(0,len(maxHeight)):
        maxHeight[i] = boxes[i][2]

    maxHeightAns = 0

    for i in range(1,len(boxes)):
        for j in range(i):

            # If the box is smaller then update current maximum height.
            if (boxes[i][1] < boxes[j][1] and boxes[i][0] < boxes[j][0]): 
                maxHeight[i] = max(maxHeight[i], maxHeight[j] + boxes[i][2])

        maxHeightAns = max(maxHeightAns, maxHeight[i])

    return maxHeightAns

C++ (g++ 5.4)

/*

    Time complexity: O(N ^ 2)
    Space complexity: O(N)

    Where N is the number of boxes.

*/


class Box 
{

public:
    int l, b, h, area;

    Box(int l, int b, int h) 
    {
        this -> l = l;
        this -> b = b;
        this -> h = h;
        this -> area = l * b;
    }
    
};

bool compareTo(Box a, Box b) 
{
        return a.area > b.area;
}

int ninjaAndBoxStack(vector& length, vector& breadth, vector& height, int n) 
{

    vector boxes;

    for (int i = 0; i < n; i++) 
    {
        boxes.push_back(Box(max(length[i], breadth[i]), min(length[i], breadth[i]), height[i]));
        boxes.push_back(Box(max(height[i], breadth[i]), min(height[i], breadth[i]), length[i]));
        boxes.push_back(Box(max(length[i], height[i]), min(length[i], height[i]), breadth[i]));
    }

    sort(boxes.begin(), boxes.end(), compareTo);

    vector maxHeight(boxes.size());

    for (int i = 0; i < maxHeight.size(); i++) 
    {
        maxHeight[i] = boxes[i].h;
    }

    int maxHeightAns = 0;

    for (int i = 1; i < boxes.size(); i++) 
    {
        for (int j = 0; j < i; j++) 
        {

            // If the box is smaller then update current maximum height.
            if (boxes[i].b < boxes[j].b && boxes[i].l < boxes[j].l) 
            {
                maxHeight[i] = max(maxHeight[i], maxHeight[j] + boxes[i].h);
            }
        }

        maxHeightAns = max(maxHeightAns, maxHeight[i]);

    }

    return maxHeightAns;
}

Ninja has been given ‘N’ rectangular 3-D ‘BOXES’. Each box has dimensions Length ‘L’, Breadth ‘B’ and Height ‘H’. Ninja has to create a stack of boxes as tall as possible. But there is a condition to do so.

You can only place a box on top of another box only if the dimensions of the 2-D base of the lower box are each strictly larger than those of the 2-D base of the higher box. You can rotate any box so that any side of the box is used as a base. You can take multiple instances of any box.

Can you help the Ninja to create a stack of boxes as tall as possible?.

Input Format :

Output Format :

Note :

Constraints :

Top Nutanix Mts1 interview questions & answers

Popular interview questions of Mts1