Program to find amount of water in a given glass

There are some glasses with equal capacity as 1 litre. The glasses are kept as follows: 
 

                   1
                 2   3
              4    5    6
            7    8    9   10

You can put water to the only top glass. If you put more than 1-litre water to 1st glass, water overflows and fills equally in both 2nd and 3rd glasses. Glass 5 will get water from both 2nd glass and 3rd glass and so on. 
If you have X litre of water and you put that water in a top glass, how much water will be contained by the jth glass in an ith row?
Example. If you will put 2 litres on top. 
1st – 1 litre 
2nd – 1/2 litre 
3rd – 1/2 litre

 For 2 Liters Water

The approach is similar to Method 2 of the Pascal’s Triangle. If we take a closer look at the problem, the problem boils down to Pascal’s Triangle
 

                           1   ---------------- 1
                 2   3 ---------------- 2
                      4    5    6  ------------ 3
            7    8    9   10  --------- 4

Each glass contributes to the two glasses down the glass. Initially, we put all water in the first glass. Then we keep 1 litre (or less than 1 litre) in it and move rest of the water to two glasses down to it. We follow the same process for the two glasses and all other glasses till the ith row. There will be i*(i+1)/2 glasses till ith row. 
 

 



C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// Program to find the amount of water in j-th glass
// of i-th row
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
// Returns the amount of water in jth glass of ith row
float findWater(int i, int j, float X)
{
    // A row number i has maximum i columns. So input
    // column number must be less than i
    if (j > i)
    {
        printf("Incorrect Inputn");
        exit(0);
    }
 
    // There will be i*(i+1)/2 glasses till ith row
    // (including ith row)
    float glass[i * (i + 1) / 2];
 
    // Initialize all glasses as empty
    memset(glass, 0, sizeof(glass));
 
    // Put all water in first glass
    int index = 0;
    glass[index] = X;
 
    // Now let the water flow to the downward glasses
    // till the row number is less than or/ equal to i (given row)
    // correction : X can be zero for side glasses as they have lower rate to fill
    for (int row = 1; row <= i ; ++row)
    {
        // Fill glasses in a given row. Number of
        // columns in a row is equal to row number
        for (int col = 1; col <= row; ++col, ++index)
        {
            // Get the water from current glass
            X = glass[index];
 
            // Keep the amount less than or equal to
            // capacity in current glass
            glass[index] = (X >= 1.0f) ? 1.0f : X;
 
            // Get the remaining amount
            X = (X >= 1.0f) ? (X - 1) : 0.0f;
 
            // Distribute the remaining amount to
            // the down two glasses
            glass[index + row] += X / 2;
            glass[index + row + 1] += X / 2;
        }
    }
 
    // The index of jth glass in ith row will
    // be i*(i-1)/2 + j - 1
    return glass[i*(i-1)/2 + j - 1];
}
 
// Driver program to test above function
int main()
{
    int i = 2, j = 2;
    float X = 2.0; // Total amount of water
 
    printf("Amount of water in jth glass of ith row is: %f",
            findWater(i, j, X));
 
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Program to find the amount
/// of water in j-th glass
// of i-th row
import java.lang.*;
 
class GFG
{
// Returns the amount of water
// in jth glass of ith row
static float findWater(int i, int j,
                       float X)
{
// A row number i has maximum i
// columns. So input column
// number must be less than i
if (j > i)
{
    System.out.println("Incorrect Input");
    System.exit(0);
}
 
// There will be i*(i+1)/2 glasses
// till ith row (including ith row)
int ll = Math.round((i * (i + 1) ));
float[] glass = new float[ll + 2];
 
// Put all water in first glass
int index = 0;
glass[index] = X;
 
// Now let the water flow to the
// downward glasses till the row
// number is less than or/ equal
// to i (given row)
// correction : X can be zero for side
// glasses as they have lower rate to fill
for (int row = 1; row <= i ; ++row)
{
    // Fill glasses in a given row. Number of
    // columns in a row is equal to row number
    for (int col = 1;
             col <= row; ++col, ++index)
    {
        // Get the water from current glass
        X = glass[index];
 
        // Keep the amount less than or
        // equal to capacity in current glass
        glass[index] = (X >= 1.0f) ? 1.0f : X;
 
        // Get the remaining amount
        X = (X >= 1.0f) ? (X - 1) : 0.0f;
 
        // Distribute the remaining amount 
        // to the down two glasses
        glass[index + row] += X / 2;
        glass[index + row + 1] += X / 2;
    }
}
 
// The index of jth glass in ith
// row will be i*(i-1)/2 + j - 1
return glass[(int)(i * (i - 1) /
                   2 + j - 1)];
}
 
// Driver Code
public static void main(String[] args)
{
    int i = 2, j = 2;
    float X = 2.0f; // Total amount of water
    System.out.println("Amount of water in jth " +
                         "glass of ith row is: " +
                              findWater(i, j, X));
}
}
 
// This code is contributed by mits

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Program to find the amount
# of water in j-th glass of
# i-th row
 
# Returns the amount of water
# in jth glass of ith row
def findWater(i, j, X):
    # A row number i has maximum
    # i columns. So input column
    # number must be less than i
    if (j > i):
        print("Incorrect Input");
        return;
 
    # There will be i*(i+1)/2
    # glasses till ith row
    # (including ith row)
    # and Initialize all glasses
    # as empty
    glass = [0]*int(i *(i + 1) / 2);
 
    # Put all water
    # in first glass
    index = 0;
    glass[index] = X;
 
    # Now let the water flow to
    # the downward glasses till
    # the row number is less
    # than or/ equal to i (given
    # row) correction : X can be
    # zero for side glasses as
    # they have lower rate to fill
    for row in range(1,i):
        # Fill glasses in a given
        # row. Number of columns
        # in a row is equal to row number
        for col in range(1,row+1):
            # Get the water
            # from current glass
            X = glass[index];
 
            # Keep the amount less
            # than or equal to
            # capacity in current glass
            glass[index] = 1.0 if (X >= 1.0) else X;
 
            # Get the remaining amount
            X = (X - 1) if (X >= 1.0) else 0.0;
 
            # Distribute the remaining
            # amount to the down two glasses
            glass[index + row] += (X / 2);
            glass[index + row + 1] += (X / 2);
            index+=1;
 
    # The index of jth glass
    # in ith row will
    # be i*(i-1)/2 + j - 1
    return glass[int(i * (i - 1) /2 + j - 1)];
 
# Driver Code
if __name__ == "__main__":
     
    i = 2;
    j = 2;
    X = 2.0;
# Total amount of water
 
    res=repr(findWater(i, j, X));
    print("Amount of water in jth glass of ith row is:",res.ljust(8,'0'));
# This Code is contributed by mits

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// Program to find the amount
// of water in j-th glass
// of i-th row
using System;
 
class GFG
{
// Returns the amount of water
// in jth glass of ith row
static float findWater(int i, int j,
                       float X)
{
// A row number i has maximum i
// columns. So input column
// number must be less than i
if (j > i)
{
    Console.WriteLine("Incorrect Input");
    Environment.Exit(0);
}
 
// There will be i*(i+1)/2 glasses
// till ith row (including ith row)
int ll = (int)Math.Round((double)(i * (i + 1)));
float[] glass = new float[ll + 2];
 
// Put all water in first glass
int index = 0;
glass[index] = X;
 
// Now let the water flow to the
// downward glasses till the row
// number is less than or/ equal
// to i (given row)
// correction : X can be zero
// for side glasses as they have
// lower rate to fill
for (int row = 1; row <= i ; ++row)
{
    // Fill glasses in a given row.
    // Number of columns in a row
    // is equal to row number
    for (int col = 1;
            col <= row; ++col, ++index)
    {
        // Get the water from current glass
        X = glass[index];
 
        // Keep the amount less than
        // or equal to capacity in
        // current glass
        glass[index] = (X >= 1.0f) ?
                              1.0f : X;
 
        // Get the remaining amount
        X = (X >= 1.0f) ? (X - 1) : 0.0f;
 
        // Distribute the remaining amount
        // to the down two glasses
        glass[index + row] += X / 2;
        glass[index + row + 1] += X / 2;
    }
}
 
// The index of jth glass in ith
// row will be i*(i-1)/2 + j - 1
return glass[(int)(i * (i - 1) /
                   2 + j - 1)];
}
 
// Driver Code
static void Main()
{
    int i = 2, j = 2;
    float X = 2.0f; // Total amount of water
    Console.WriteLine("Amount of water in jth " +
                        "glass of ith row is: " +
                             findWater(i, j, X));
}
}
 
// This code is contributed by mits

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// Program to find the amount
// of water in j-th glass of
// i-th row
 
// Returns the amount of water
// in jth glass of ith row
function findWater($i, $j, $X)
{
    // A row number i has maximum
    // i columns. So input column
    // number must be less than i
    if ($j > $i)
    {
        echo "Incorrect Input\n";
        return;
    }
 
    // There will be i*(i+1)/2
    // glasses till ith row
    // (including ith row)
    // and Initialize all glasses
    // as empty
    $glass = array_fill(0, (int)($i *
                       ($i + 1) / 2), 0);
 
    // Put all water
    // in first glass
    $index = 0;
    $glass[$index] = $X;
 
    // Now let the water flow to
    // the downward glasses till
    // the row number is less
    // than or/ equal to i (given 
    // row) correction : X can be
    // zero for side glasses as
    // they have lower rate to fill
    for ($row = 1; $row < $i ; ++$row)
    {
        // Fill glasses in a given
        // row. Number of columns
        // in a row is equal to row number
        for ($col = 1;
             $col <= $row; ++$col, ++$index)
        {
            // Get the water
            // from current glass
            $X = $glass[$index];
 
            // Keep the amount less
            // than or equal to
            // capacity in current glass
            $glass[$index] = ($X >= 1.0) ?
                                     1.0 : $X;
 
            // Get the remaining amount
            $X = ($X >= 1.0) ?
                    ($X - 1) : 0.0;
 
            // Distribute the remaining
            // amount to the down two glasses
            $glass[$index + $row] += (double)($X / 2);
            $glass[$index + $row + 1] += (double)($X / 2);
        }
    }
 
    // The index of jth glass
    // in ith row will
    // be i*(i-1)/2 + j - 1
    return $glass[(int)($i * ($i - 1) /
                          2 + $j - 1)];
}
 
// Driver Code
$i = 2;
$j = 2;
$X = 2.0; // Total amount of water
echo "Amount of water in jth " ,
        "glass of ith row is: ".
       str_pad(findWater($i, $j,
                   $X), 8, '0');
 
// This Code is contributed by mits
?>

chevron_right


Output: 

Amount of water in jth glass of ith row is: 0.500000

Time Complexity: O(i*(i+1)/2) or O(i^2) 
Auxiliary Space: O(i*(i+1)/2) or O(i^2)
This article is compiled by Rahul and reviewed by GeeksforGeeks team. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

Method 2 (Using BFS Traversal)

we will discuss another approach to this problem. First, we add a Triplet(row, col,rem-water) in the queue which indicates the starting value of the first element and fills 1-litre water.  Then we simply apply bfs i.e. and we add left(row+1, col-1,rem-water) Triplet and right(row+1, col+1,rem-water) Triplet into the queue with half of the remaining water in first Triplet and another half into the next Triplet.

Following is the implementation of this solution.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program for above approach
#include<bits/stdc++.h>
using namespace std;
 
// Program to find the amount 
// of water in j-th glass
// of i-th row
void findWater(float k, int i, int j)
{
     
    // stores how much amount of water
    // present in every glass 
    float dp[i+1][2*i + 1];
    bool vis[i+1][2*i + 1];
     
    // initialize dp and visited arrays
    for(int n=0;n<i+1;n++)
    {
        for(int m=0;m<(2*i+1);m++)
        {
            dp[n][m] = 0;
            vis[n][m] = false;
        }
    }
     
    // store Triplet i.e curr-row , curr-col
    queue<pair<int,int>>q;
    dp[0][i] = k;
     
    // we take the center of the first row for
    // the location of the first glass
    q.push({0,i});
    vis[0][i] = true;
     
    // this while loop runs unless the queue is not empty
    while(!q.empty())
    {
        // First we remove the pair from the queue
        pair<int,int>temp = q.front();
        q.pop();
        int n = temp.first;
        int m = temp.second;
         
         
        // as we know we have  to calculate the
        // amount of water in jth glass
        // of ith row . so first we check if we find solutions
        // for the the every glass of i'th row.
        // so, if we have calculated the result
        // then we break the loop
        // and return our answer
        if(i == n)
            break;
             
             
        float x = dp[n][m];
        if(float((x-1.0)/2.0) < 0)
        {
            dp[n+1][m-1] += 0;
            dp[n+1][m+1] += 0;
        }
        else
        {
            dp[n+1][m-1] += float((x-1.0)/2.0);
            dp[n+1][m+1] += float((x-1.0)/2.0);   
        }
        if(vis[n+1][m-1]==false)
        {
            q.push({n+1,m-1});
            vis[n+1][m-1] = true;
        }
        if(vis[n+1][m+1]==false)
        {
            q.push({n+1,m+1});
            vis[n+1][m+1] = true;
        }
    }
    
    if(dp[i-1][2*j-1]>1)
        dp[i-1][2*j-1] = 1.0;
         
    cout<<"Amount of water in jth glass of ith row is: ";
     
    // print the result for jth glass of ith row
    cout<<fixed<<setprecision(6)<<dp[i-1][2*j-1]<<endl;
 
}
 
// Driver Code
int main()
{
     
    //k->water in litres
    float k; 
    cin>>k;
   
    //i->rows  j->cols
    int i,j;
    cin>>i>>j; 
   
    // Function Call 
    findWater(k,i,j);
    return 0;
}
 
 // This code is contibuted by Sagar Jangra and Naresh Saharan

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Program to find the amount 
/// of water in j-th glass
// of i-th row
import java.io.*;
import java.util.*;
 
// class Triplet which stores curr row
// curr col and curr rem-water
// of every glass
class Triplet
{
  int row;
  int col;
  double rem_water;
  Triplet(int row,int col,double rem_water)
  {
    this.row=row;this.col=col;this.rem_water=rem_water;
  }
}
 
 
class GFG
{
  // Returns the amount of water
  // in jth glass of ith row
  public static double findWater(int i,int j,int totalWater)
  {
 
    // stores how much amount of water present in every glass  
    double dp[][] = new double[i+1][2*i+1];
 
    // store Triplet i.e curr-row , curr-col, rem-water
    Queue<Triplet> queue = new LinkedList<>();
 
    // we take the center of the first row for
    // the location of the first glass
    queue.add(new Triplet(0,i,totalWater));
 
 
    // this while loop runs unless the queue is not empty
    while(!queue.isEmpty())
    {
      // First we remove the Triplet from the queue
      Triplet curr = queue.remove();
 
      // as we know we have  to calculate the
      // amount of water in jth glass
      // of ith row . so first we check if we find solutions
      // for the the every glass of i'th row.
      // so, if we have calculated the result
      // then we break the loop
      // and return our answer
      if(curr.row == i)
        break;
 
      // As we know maximum capacity of every glass
      // is 1 unit. so first we check the capacity
      // of curr glass is full or not.
      if(dp[curr.row][curr.col] != 1.0)
      {
        // calculate the remaining capacity of water for curr glass
        double rem_water = 1-dp[curr.row][curr.col];
 
        // if the remaining capacity of water for curr glass
        // is greater than then the remaining capacity of tatal
        // water then we put all remaining water into curr glass
        if(rem_water > curr.rem_water)
        {
          dp[curr.row][curr.col] += curr.rem_water;
          curr.rem_water = 0;
        }
        else
        {
          dp[curr.row][curr.col] += rem_water;
          curr.rem_water -= rem_water;
        }
      }
 
      // if remaining capacity of tatal water is not equal to
      // zero then we add left and right glass of the next row
      // and gives half capacity of tatal water to both the
      // glass
      if(curr.rem_water != 0)
      {
        queue.add(new Triplet(curr.row + 1,curr.col -
                                  1,curr.rem_water/2.0));
        queue.add(new Triplet(curr.row + 1,curr.col +
                                  1,curr.rem_water/2.0));
      }
    }
 
    // return the result for jth glass of ith row
    return dp[i-1][2*j-1];
  }
 
  // Driver Code
  public static void main (String[] args)
  {
    int i = 2, j = 2;
    int totalWater = 2; // Total amount of water
    System.out.print("Amount of water in jth glass of ith row is:");
    System.out.format("%.6f", findWater(i, j, totalWater));  
  }
 
}
  // this code is contibuted by  Naresh Saharan and Sagar Jangra

chevron_right


Output

Amount of water in jth glass of ith row is:0.500000

Time Complexity:  O(2^i)

Space Complexity:  O(i^2)
 

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.




My Personal Notes arrow_drop_up