Open In App

Total number of different staircase that can made from N boxes

Improve
Improve
Like Article
Like
Save
Share
Report

Given N boxes of unit dimension, i.e. (1×1 meter^2     ). The task is to find the total number of different staircases that can be made from those boxes with the following rules: 

  • The staircase must be in strictly descending order.
  • Each staircase contains at least two steps. ( The total steps are equal to the breadth of the staircase.)


Examples

Input : N = 5 
Output : 2 
The two staircases are the following : 


Input : N = 6 
Output : 3 
The three staircases are the following :  

If we consider total steps = 2, we can observe the fact that the number of staircases is incremented by 1 if N is incremented by 2. We can illustrate the above things from the following image: 

Now, if the total steps are greater than 2 (assume, total steps = K), then we can take this thing as first create a base (base requires boxes equal to the total steps) for the staircase and put another staircase on it of steps size K and K – 1 have boxes N – K. (because K boxes already used to create base). Thus, we can solve this problem using bottom-up dynamic programming.


Below is the implementation of the above approach: 

C++

// C++ program to find the total number of
// different staircase that can made
// from N boxes
#include <iostream>
using namespace std;
 
// Function to find the total number of
// different staircase that can made
// from N boxes
int countStaircases(int N)
{
    // DP table, there are two states.
    // First describes the number of boxes
    // and second describes the step
    int memo[N + 5][N + 5];
 
    // Initialize all the elements of
    // the table to zero
    for (int i = 0; i <= N; i++) {
        for (int j = 0; j <= N; j++) {
            memo[i][j] = 0;
        }
    }
 
    // Base case
    memo[3][2] = memo[4][2] = 1;
 
    for (int i = 5; i <= N; i++) {
        for (int j = 2; j <= i; j++) {
 
            // When step is equal to 2
            if (j == 2) {
                memo[i][j] = memo[i - j][j] + 1;
            }
 
            // When step is greater than 2
            else {
                memo[i][j] = memo[i - j][j] +
                             memo[i - j][j - 1];
            }
        }
    }
 
    // Count the total staircase
    // from all the steps
    int answer = 0;
    for (int i = 1; i <= N; i++)
        answer = answer + memo[N][i];   
 
    return answer;
}
 
// Driver Code
int main()
{
    int N = 7;
 
    cout << countStaircases(N);
 
    return 0;
}

                    

Java

// Java program to find the total number of
// different staircase that can made
// from N boxes
 
import java.util.*;
 
class GFG
{
        // Function to find the total number of
        // different staircase that can made
        // from N boxes
        static int countStaircases(int N)
        {
            // DP table, there are two states.
            // First describes the number of boxes
            // and second describes the step
            int [][] memo=new int[N + 5][N + 5];
         
            // Initialize all the elements of
            // the table to zero
            for (int i = 0; i <= N; i++) {
                for (int j = 0; j <= N; j++) {
                    memo[i][j] = 0;
                }
            }
         
            // Base case
            memo[3][2] = memo[4][2] = 1;
         
            for (int i = 5; i <= N; i++) {
                for (int j = 2; j <= i; j++) {
         
                    // When step is equal to 2
                    if (j == 2) {
                        memo[i][j] = memo[i - j][j] + 1;
                    }
         
                    // When step is greater than 2
                    else {
                        memo[i][j] = memo[i - j][j] +
                                    memo[i - j][j - 1];
                    }
                }
            }
         
            // Count the total staircase
            // from all the steps
            int answer = 0;
            for (int i = 1; i <= N; i++)
                answer = answer + memo[N][i];
         
            return answer;
        }
         
        // Driver Code
        public static void main(String [] args)
        {
            int N = 7;
         
            System.out.println(countStaircases(N));
         
             
        }
 
}
 
// This code is contributed
// by ihritik

                    

Python 3

# Python 3 program to find the total
# number of different staircase that
# can made from N boxes
 
# Function to find the total number
# of different staircase that can
# made from N boxes
def countStaircases(N):
 
    # DP table, there are two states.
    # First describes the number of boxes
    # and second describes the step
    memo = [[0 for x in range(N + 5)]
               for y in range(N + 5)]
 
    # Initialize all the elements of
    # the table to zero
    for i in range(N + 1):
        for j in range (N + 1):
            memo[i][j] = 0
         
    # Base case
    memo[3][2] = memo[4][2] = 1
 
    for i in range (5, N + 1) :
        for j in range (2, i + 1) :
 
            # When step is equal to 2
            if (j == 2) :
                memo[i][j] = memo[i - j][j] + 1
             
            # When step is greater than 2
            else :
                memo[i][j] = (memo[i - j][j] +
                              memo[i - j][j - 1])
     
    # Count the total staircase
    # from all the steps
    answer = 0
    for i in range (1, N + 1):
        answer = answer + memo[N][i]
 
    return answer
 
# Driver Code
if __name__ == "__main__":
 
    N = 7
 
    print (countStaircases(N))
 
# This code is contributed
# by ChitraNayal

                    

C#

// C# program to find the total number
// of different staircase that can made
// from N boxes
using System;
 
class GFG
{
     
// Function to find the total number
// of different staircase that can
// made from N boxes
static int countStaircases(int N)
{
    // DP table, there are two states.
    // First describes the number of boxes
    // and second describes the step
    int [,] memo = new int[N + 5, N + 5];
 
    // Initialize all the elements
    // of the table to zero
    for (int i = 0; i <= N; i++)
    {
        for (int j = 0; j <= N; j++)
        {
            memo[i, j] = 0;
        }
    }
 
    // Base case
    memo[3, 2] = memo[4, 2] = 1;
 
    for (int i = 5; i <= N; i++)
    {
        for (int j = 2; j <= i; j++)
        {
 
            // When step is equal to 2
            if (j == 2)
            {
                memo[i, j] = memo[i - j, j] + 1;
            }
 
            // When step is greater than 2
            else
            {
                memo[i, j] = memo[i - j, j] +
                             memo[i - j, j - 1];
            }
        }
    }
 
    // Count the total staircase
    // from all the steps
    int answer = 0;
    for (int i = 1; i <= N; i++)
        answer = answer + memo[N, i];
 
    return answer;
}
 
// Driver Code
public static void Main()
{
    int N = 7;
 
    Console.WriteLine(countStaircases(N));
}
}
 
// This code is contributed
// by Subhadeep

                    

PHP

<?php
// PHP program to find the total
// number of different staircase
// that can made from N boxes
 
// Function to find the total
// number of different staircase
// that can made from N boxes
function countStaircases($N)
{
     
    // Initialize all the elements
    // of the table to zero
    for ($i = 0; $i <= $N; $i++)
    {
        for ($j = 0; $j <= $N; $j++)
        {
            $memo[$i][$j] = 0;
        }
    }
 
    // Base case
    $memo[3][2] = $memo[4][2] = 1;
 
    for ($i = 5; $i <= $N; $i++)
    {
        for ($j = 2; $j <= $i; $j++)
        {
 
            // When step is equal to 2
            if ($j == 2)
            {
                $memo[$i][$j] = $memo[$i - $j][$j] + 1;
            }
 
            // When step is greater than 2
            else
            {
                $memo[$i][$j] = $memo[$i - $j][$j] +
                                $memo[$i - $j][$j - 1];
            }
        }
    }
 
    // Count the total staircase
    // from all the steps
    $answer = 0;
    for ($i = 1; $i <= $N; $i++)
        $answer = $answer + $memo[$N][$i];
 
    return $answer;
}
 
// Driver Code
$N = 7;
 
echo countStaircases($N);
 
// This code is contributed
// by Shivi_Aggarwal
?>

                    

Javascript

<script>
        // Javascript program to find the total number of
        // different staircase that can made
        // from N boxes
     
        // Function to find the total number of
        // different staircase that can made
            // from N boxes
        function countStaircases(N)
        {
            // DP table, there are two states.
            // First describes the number of boxes
            // and second describes the step
            let memo=new Array(N + 5);
             for(let i=0;i<N+5;i++)
            {
                memo[i]=new Array(N+5);
                for(let j=0;j<N+5;j++)
                {
                    memo[i][j]=0;
                }
            }
            // Initialize all the elements of
            // the table to zero
            for (let i = 0; i <= N; i++) {
                for (let j = 0; j <= N; j++) {
                    memo[i][j] = 0;
                }
            }
          
            // Base case
            memo[3][2] = memo[4][2] = 1;
          
            for (let i = 5; i <= N; i++) {
                for (let j = 2; j <= i; j++) {
          
                    // When step is equal to 2
                    if (j == 2) {
                        memo[i][j] = memo[i - j][j] + 1;
                    }
          
                    // When step is greater than 2
                    else {
                        memo[i][j] = memo[i - j][j] +
                                    memo[i - j][j - 1];
                    }
                }
            }
          
            // Count the total staircase
            // from all the steps
            let answer = 0;
            for (let i = 1; i <= N; i++)
                answer = answer + memo[N][i];
          
            return answer;
           }
     
        // Driver Code
        let N = 7;
        document.write(countStaircases(N));
     
 
// This code is contributed by rag2127
</script>

                    

Output: 
4

 

Time Complexity: O(n^2     ).

Auxiliary Space: O(n ^ 2)



Last Updated : 22 Aug, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads