Number of containers that can be filled in the given time

Given a number N and a time X unit, the task is to find the number of containers that are filled completely in X unit if containers are arranged in pyramid fashion as shown below. 

Note: Below example is the pyramid arrangement for N = 3, where N denotes the number of levels in the pyramid-shaped arrangement of containers such that level 1 has 1 container, level 2 has 2 containers and up to level N. The liquid is always poured in the topmost container at the 1st level. When the container of one level overflows from both its sides, the containers of the lower levels are filled. The amount of liquid poured in each second is equal to the volume of the container. 

Examples:

Input: N = 3, X = 5 
Output: 4 
After 1 second, the container at level 1 gets fully filled. 
After 2 seconds, the 2 containers at level 2 are half-filled. 
After 3 seconds, the 2 containers at level 2 are fully filled. 
After 4 seconds, out of the 3 containers at level 3, the 2 containers at the ends are quarter-filled and the container at the center is half-filled. 
After 5 seconds, out of the 3 containers at level 3, the 2 containers at the ends are half-filled and the container at the center is fully filled.

Input: N = 4, X = 8 
Output: 6 

Approach: This problem is solved using Greedy Approach. Below are the steps:  

• After the container is getting filled, the liquid overflows equally from both the sides of the container and fills the containers below it.
• Consider this pyramid of containers as a matrix. So, cont[i][j] is the liquid in j^th container of i^th row.
• So, when overflow occurs, the liquid flows to cont[i+1][j] and cont[i+1][j+1].
• As the liquid will be poured for X seconds, so the total amount of liquid poured is X units.
• So the maximum value that can be poured into a container can be X units and minimum value that can be poured to completely fill it is 1 unit.

As the liquid is poured into the topmost container always, let the topmost container has a maximum value i.e. X units. 
Steps for the algorithm are as follows:  

1. Start the outer loop from 1 to N for n containers at each level. Inside this loop, start another loop for 1 to i, for each container of each row. Also declare a counter, count = 0, for counting the containers which are getting filled.
2. If value of cont[i][j] is greater than or equal to 1(it means it is filled) then, count is incremented by 1, and then in cont[i+1][j] & g[i+1][j+1] the liquid gets poured and their value is increased by value of (g[i][j]-1)/2 respectively, because the liquid is divided in half amount in both of them.
3. In this way continue the loop, and incrementing the countfor each filled container. When the loop ends our count will be the required answer.

Below is the implementation of the above approach:  

C++

// C++ program for the above problem
#include <bits/stdc++.h>
using namespace std;

// matrix of containers
double cont[1000][1000];

// function to find the number
// of containers that will be
// filled in X seconds
void num_of_containers(int n,
                       double x)
{
    int count = 0;

    // container on top level
    cont[1][1] = x;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= i; j++) {

            // if container gets filled
            if (cont[i][j] >= (double)1) {
                count++;

                // dividing the liquid
                // equally in two halves
                cont[i + 1][j]
                    += (cont[i][j]
                        - (double)1)
                       / (double)2;

                cont[i + 1][j + 1]
                    += (cont[i][j]
                        - (double)1)
                       / (double)2;
            }
        }
    }
    cout << count;
}

// driver code
int main()
{
    int n = 3;
    double x = 5;
    num_of_containers(n, x);
    return 0;
}

Java

// Java program for the above problem
import java.util.*;

class GFG{

// Matrix of containers
static double cont[][] = new double[1000][1000];

// Function to find the number
// of containers that will be
// filled in X seconds
static void num_of_containers(int n, double x)
{
    int count = 0;

    // Container on top level
    cont[1][1] = x;
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= i; j++)
        {

            // If container gets filled
            if (cont[i][j] >= (double)1)
            {
                count++;

                // Dividing the liquid
                // equally in two halves
                cont[i + 1][j] += (cont[i][j] -
                                   (double)1) /
                                   (double)2;

                cont[i + 1][j + 1] += (cont[i][j] -
                                       (double)1) /
                                       (double)2;
            }
        }
    }
    System.out.print(count);
}

// Driver code
public static void main(String[] args)
{
    int n = 3;
    double x = 5;

    num_of_containers(n, x);
}
}

// This code is contributed by jrishabh99

Python3

# Python3 program for the above problem

# Matrix of containers
cont = [[ 0 for i in range(1000)]
            for j in range(1000)]

# Function to find the number
# of containers that will be
# filled in X seconds
def num_of_containers(n, x):

    count = 0

    # Container on top level
    cont[1][1] = x

    for i in range(1, n + 1):
        for j in range(1, i + 1):

             # If container gets filled
             if (cont[i][j] >= 1):
                count += 1

                # Dividing the liquid
                # equally in two halves
                cont[i + 1][j] += (cont[i][j] - 1) / 2
                cont[i + 1][j + 1] += (cont[i][j] - 1) / 2

    print(count)

# Driver code
n = 3
x = 5

num_of_containers(n, x)

# This code is contributed by yatinagg

C#

// C# program for the above problem
using System;

class GFG{

// Matrix of containers
static double [,]cont = new double[1000, 1000];

// Function to find the number
// of containers that will be
// filled in X seconds
static void num_of_containers(int n, double x)
{
    int count = 0;

    // Container on top level
    cont[1, 1] = x;
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= i; j++)
        {

            // If container gets filled
            if (cont[i, j] >= (double)1)
            {
                count++;

                // Dividing the liquid
                // equally in two halves
                cont[i + 1, j] += (cont[i, j] -
                                  (double)1) /
                                  (double)2;

                cont[i + 1, j + 1] += (cont[i, j] -
                                      (double)1) /
                                      (double)2;
            }
        }
    }
    Console.Write(count);
}

// Driver code
public static void Main(String[] args)
{
    int n = 3;
    double x = 5;

    num_of_containers(n, x);
}
}

// This code is contributed by Princi Singh

Javascript

<script>

// Javascript program for the above problem

// function to find the number
// of containers that will be
// filled in X seconds
function num_of_containers(n, x)
{
    var cont = new Array(100);
    var i;
    var j;
    for (i=0;i<cont.length;i++)
        cont[i] = new Array(100);
    for(i=0;i<cont.length;i++){
        for (j=0;j<cont[i].length;j++)
          cont[i][j] = 0;
    }
    var count = 0;
    // container on top level
    cont[1][1] = x;
    for (i = 1; i <= n; i++) {
        for (j = 1; j <= i; j++) {

            // if container gets filled
            if (cont[i][j] >=  1) {
                count += 1;

                // dividing the liquid
                // equally in two halves
                cont[i + 1][j]
                    += (cont[i][j]
                        - 1)
                       / 2;

                cont[i + 1][j + 1]
                    += (cont[i][j]
                        - 1)
                       / 2;
            }
        }
    }
    document.write(count);
}

// driver code
    var n = 3;
    var x = 5;
    num_of_containers(n, x);

</script>

Output

4

Time Complexity: O(N²) 
Auxiliary space Complexity: O(N²)