Trapping of rainwater problem in Data Structure

Introduction

If you notice that there are greater bars on both sides, left and right, then a component within the array can hold water. The respective heights that correspond to the bars on both sides may be used to determine how much water has to be kept in each position.

The total quantity of water contained for every index is the total quantity of liquid contained. On a standing height chart, the dimension of every single bar is 1. Calculate the elevations of the topographical mapping bars, and positive integers and decimals can represent these to get the amount of water that can be stored when it rains.

Example

Input:

Output:

Let's examine the reasoning for the case above:

A topographic map is provided below to symbolize the supplied heights mentioned above:

Trapping of rainwater problem in Data Structure

Here:

The initial block can contain three units of rainwater.

A single unit of water may be contained within the second block of space.

The third structure can contain three units of water.

The fourth block can contain one unit of water.

Thus, the area that water occupies inside the container is equal to

The concept underlying the solution to the rainfall water trapping challenge is that rainwater can only be held in a single unit, provided blocks of higher height exist along both the right and left sides of the present block form.

Rainfall water gets trapped on the highest point of the present block as a result of this. Thus, it is evident that the greatest and lowest elevations that can be found on the flowing block's right and left sides, less the block's overall elevation, determine the volume of fluid that could be trapped.

There are five approaches to solving the enmeshing rainwater problem; those are mentioned below.

Brute force Approach
Prefix and suffix arrays
Using heaps
Horizontal scan system
Using two pointers

Approach 1 (Brute Approach):

Look through each member of the array to identify the largest bars on both sides of the array.

Choose the shorter of both altitudes. The volume of water this array component can hold equals the distinction between its present maximum and its reduced height. To put the concept into practice, take the following actions: Go from beginning to finish in the array:

Regarding each component: Beginning at this index, explore the array of values to get the highest possible height (a) and obtain the greatest height (b) by traversing through the collection, starting with the present index and moving to the final position. Add this number to determine the overall quantity of water that has been saved. The total quantity of fluid that is going to be saved within these columns is min(a,b) - array[i]. Put the whole quantity of water saved.

The first method-a brute force approach-for collecting rainwater is provided below. We need to get the highest possible height on both the left and right sides for every component (i.e., blocks) within the array, so walk over each element in the array []. For each component (i.e., blocks), find the highest point on the left and the greatest point on the opposite side. In the present block, add min(right_max_height, left_max_height)-Arr[i] as a result (caught fluid).

The algorithmic stages for this method are listed as follows:

Make variable called res and set its starting point to 0.
Explore the array Arr[] from 1 to n for each value:
At startup, set both max_left and max_right to 0.
Move Arr[i] to the beginning of the collection to make changes to the left maximum:
max_left = max(Arr[i], max_left)
Modify the right max in the same manner by shifting A [i] to the final segment of the resulting array. right_maximum = max(Arr[i], max_right)
Incorporate Arr[i] - min(left_maximum, max_right) into res.

Implementation using Brute force approach:

//Python code for implementation of trapping of rainwater using brute force approach:

def trap_rainwater(Arr, N) :
    ans = 0;
    for k in range(1, N-1) :
        max_left = Arr[k];
        for l in range(k) :
            max_left = max(max_left, Arr[l]);
        max_right = Arr[k];
        for l in range(k + 1 , N) :
            max_right = max(max_right, Arr[l]);
        ans = ans + (min(max_left, max_right) - Arr[k]);
    return ans;
Arr=[4,3,0,2,0,2,3]
N=len(Arr)
print("The overall quantity of trapped water is equal to:")
print(trap_rainwater(Arr,N))

Output:

The output of the above code is:

Explanation

The program determines how much precipitation may be caught in a series of houses depicted at a range of elevations. It accomplishes these by deducting the height of the structure from the greatest amount of water that might be contained across every building's surface.

The greatest elevations of water that could be confined towards the left and right of each building are initially stored in an array called left_max and right_max, respectively, by the program's code. By repeating over the array going left to right and keeping the tune of the tune of the greatest apparent number until now, the left_max array gets populated.

The right_max array is stuffed by repeating through the array from right to left and keeping track of the zenith seen up to now. Once the left_max and right_max arrays are stuffed, the law iterates through the array over again. For every structure, it calculates the volume of water that could be trapped with the aid of a system of taking the minimum of the left_max and right_max values for that construction and decreasing the peak of the structure itself.

The typical volume of trapped water is also amassed again and again. Then's an illustration of the way the law works for the array( 4, 3, 0, 2, 0, 2, 3)

The left_max array is packed with the values(4, 4, 4, 4, 4, 4).

The right_max array is full of the values(3, 3, 3, 3, 2, 2).

The law iterates through the array and calculates the volume of water that could be trapped for each structure.

For constructing 0, the quantum of water that might be trapped is min(4, 3)-zero = 3.
For constructing 1, the volume of water that would be trapped is min(4, 3)- 3 = 0.
For structure 2, the volume of water that might be trapped is min(4, 3) - 0 = 3.
For constructing 3, the quantum of water that might be trapped is min(4, 3)- 2 = 1.
For constructing 4, the volume of water that might be trapped is min(3, 2) - 0 = 2.
For constructing 5, the volume of water that could be trapped is min(3, 2)- 2 = 0.
For constructing 6, the volume of water that's presumably trapped is min(2, 2)- 3 = -1( but we cannot have terrible water, so we set it to zero).
The general volume of water that would be trapped is thus 3+0 +3+1+2+0+0 = 9.

Time Complexity

O (n2), as for each value, the right and left sides are covered.

Space Complexity

O (1), as no fresh space is used while enforcing this approach.

Approach 2(Prefix and Suffix Arrays or Pre-Calculation)

An alternate approach for enmeshing rainwater that uses prefix and suffix arrays is given below. Now, we will increase the effectiveness from O( N2) to O( N). Keep in mind that we're covering left as well as right for each element when using brute force. However, we can solve the issue with just one traversal, effectively lowering the time complexity to O (N) if we store this data.

It's suggested to suppose two arrays, the left maximum and the right maximum, where the left maximum (i) will store the loftiest point on the left up to the indicator. Analogous to that, right maximum (i) will keep track of the right's maximum height up until indicator i.

Algorithm

Produce two arrays, i.e., the right maximum and the left maximum of sizes.
Produce a variable m = 0.
Keep covering from left to right, streamlining mix = maximum (mix, Arr(i)), and setting left outside = mix for each indicator. Analogously, cut a circle from N to 1 and update mxi = maximum(mxi, Arr (i)) and allocate right outside = mxi for each indicator.
Set a variable's original value to 0, and also go from 0 to N-1. Add min(left outside(i), right outside(i))- Arr(i) to each indicator.
This is an effective result grounded in the pre-calculation conception.
In the former approach, for every element, we demanded to calculate the loftiest element on the left and the right.
So, to reduce the time complexity.
For every element, we can pre-calculate and store the loftiest bar on the left and on the right (say, stored in arrays left() and right()).
Also, reiterate the array and use the pre-calculated values to find the quantity of water stored in this indicator. Which is the same as (min (left(i), right(i)) - arr(i))
Follow the illustration below for a better understanding.
Illustration

Consider arr() = { 3, 0, 2, 0, 4}

Thus, left() = { 3, 3, 3, 3, 4} and right() = { 4, 4, 4, 4, 4}.

Now consider repeating using i from 0 to end.

For i = 0,

> left (0, 0) = 3, right (0, 0) = 4, and arr (0, 0) = 3.

= > Water stored = min(left wing(0), right-wing(0)) - are(0) = min(3, 4) - 3 = 3 - 3 = 0

= > Total = 0 0 = 0

For i = 1,

= > left( 1) = 3, right( 1) = 4, and arr( 1) = 0.

= > Water stored = min(left wing( 1), right( 1)) - arr( 1) = min(3, 4) - 0 = 3 - 0 = 3

= > Total = 0 3 = 3

For i = 2,

= > left( 2) = 3, right( 2) = 4, and arr( 2) = 2.

= > Water stored = min(left wing( 2), right-wing ( 2)) - arr( 2) = min(3, 4) - 2 = 3 - 2 = 1

= > Total = 3 1 = 4

For i = 3,

= > left( 3) = 3, right( 3) = 4, and arr( 3) = 0.

= > Water stored = min(left wing( 3), right wing ( 3)) - arr(33) = min(3, 4). - 0 = 3 - 0 = 3

= > Total = 4 3 = 7

For i = 4,

= > left( 4) = 4, right( 4) = 4, and arr( 4) = 4.

=> Water stored = min(left wing( 4), right wing(4)) - arr(4) = min(4, 4) - 4 = 4 - 4 = 0

= > Total = 7 0 = 7

So total rainwater trapped = 7

Follow the steps mentioned below to apply the approach.

Produce two arrays (left() and right()) of size N. Produce a variable(say, maximum) to store the outside setup until a certain indicator during traversal.

Run one circle from launch to end.

In each replication, update the maximum and also assign left(i) = max.

Run another circle from end to start.

In each replication update, set the maximum set up until now and also assign right(i) = max.

Traverse the array from launch to end.

The quantum of water that will be stored in this column is min (left(i), right(i)) - array(i).

Add this value to the total quantity of water stored.

Publish the total quantity of water stored.

Implementation of the method in Python

# Python program to find the maximum amount of water that can be trapped within a given set of bars. 
def trappingwater(arr, n): 
	leftmax = [0]*n 
	rightmax = [0]*n 
	water = 0#initializing the result
	# Filling the left array 
	leftmax[0] = arr[0] 
	for i in range(1, n): 
		leftmax[i] = max(leftmax[i-1], arr[i]) 
	# Filling the right array 
	rightmax[n-1] = arr[n-1] 
	for i in range(n-2, -1, -1): 
		rightmax[i] = max(rightmax[i + 1], arr[i]) 
	for i in range(0, n): 
		water += min(leftmax[i], rightmax[i]) - arr[i] 
	return water 
if __name__ == '__main__': 
	arr = [0, 9, 0, 2, 1,4 , 1, 3, 2, 1, 2, 1] 
	n = len(arr) 
	print("The result of the program pf trapping is:")
	print(trappingwater(arr, n))

Output:

Explanation:

The law calculates the volume of rainwater that may be trapped among a chain of homes represented by an array of heights. It does this by locating the top of the water that would be trapped on both aspects of every structure and also decreasing the peak of the structure itself.

The law first initializes arrays, left max, and right max, to maintain the maximum heights of water that could be trapped to the left wing and right of every structure independently. The leftmax array is stuffed by means of repeating through the array from left to right and keeping track of the maximum top visible to date. The rightmax array is filled via a system of repeating via the array from right to left, conserving the song of the zenith seen so far.

Once the left max and right max arrays are crammed, the law iterates through the array again. For each construction, it calculates the volume of water that could be trapped by taking the minimum of the left max and right max values for that structure and decreasing the height of the structure itself. The standard quantum of trapped water is also collected from the lower reverse.

Then an illustration of how the law works for the array( 0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1).

The left-max array is filled with the values( 0, 1, 1, 2, 2, 2, 3, 3).

The rightmax array is full of the values( 3, 3, 3, 3, 2, 2, 2, 2, 1, 1, 1).

The law iterates via the array and calculates the volume of water that's presumably trapped for each construction.

For structure 0, the volume of water that could be trapped is min(0, 3)-0 = 3.
For constructing 1, the volume of water that's presumably trapped is min(1, 3)- 1 = 0.
For constructing 2, the volume of water that would be trapped is min(1, 3) - 0 = 1.
For structure 3, the volume of water that would be trapped is min(2, 3)- 2 = 0.
For structure 4, the quantum of water that could be trapped is min(2, 2) - 1 = 1.
For constructing 5, the volume of water that would be trapped is min(2, 2) - 0 = 2.
For constructing 6, the volume of water that might be trapped is min(2, 2) - 1 = 1.
For structure 7, the volume of water that would be trapped is min(3, 2) - 1 = 1.
For structure 8, the quantum of water that might be trapped is min(3, 1)-2 = 0.
For structure 9, the volume of water that's presumably trapped is min (3, 1) minus 1 = 0.
For constructing 10, the quantum of water that could be trapped is min(3, 1)-2 = 0.
For structure 11, the volume of water that might be trapped is min(3, 1)-1 = 0.
The standard quantum of water that could be trapped is accordingly 0+0+1+0+1+ 2+1+1+0+0+0+0 = 6.

The time complexity of the law is O (n), wherein n is the period of the input array. This is due to the reality that the law iterates through the array in three cases: formerly to fill the left max array, as soon as to fill the right max array, and formerly to calculate the volume of water that's presumably trapped for every structure.

The space complexity of the law is O (n), where n is the length of the input array. This is due to the fact that the law makes use of two arrays, left max and right max, each of which has a size of n.

Approach 3 (using stack)

The idea to solve the problem using stacks is as follows:

We can use a stack to track the bars that are bounded by the advanced left and right bars. This can be done using only one replication.

For this, we will keep pushing rudiments into the stack until an element with a more advanced value than the stack top is set up. This denotes that there's a chance of storing position on the left side of the current element, with the current bar being an end.

So remove the lower element on the left and find the left bar( which is the current top of the stack) and the quantum of water stored by the left end bar, with the current bar being the right end. Continue this till the stack isn't empty or an advanced value element is set up.

Follow the illustration below for a better understanding.

Algorithm

Consider the array arr() = { 3, 0, 2, 0, 4} and an empty stack.

For i = 0,

The stack is empty. So, no rudiments, with advanced value on the left.

=> Push the indicator into the stack. st = { 0}( to keep track of the distance in between)

For i = 1,

= > arr( 1) is lower than arr( stack top). So arc ( 1) has an advanced left-wing bound.

=> Push the indicator into the stack. st = { 0, 1}

For i = 2,

= > arr(2) is less than arr(stack top). So are, (2) is the advanced right bound of the current stack top.

= > Calculate the amount of water stored in between the left and right bounds of the stack top.

The stack top is the base height in between the left and right bounds.

=> Pop the stack top. So st = { 0}.

= > Water stored in between when arr( 0) and arr( 2) are the bound = { min( arr( 0), arr( 2)) - arr( 1)} *( 2 - 0 - 1) = 2.

= > arr(0) is less than arr(2). Push the indicator into the stack. st = { 0, 2}.

= > Total water stored = 0 2 = 2.

For i = 3,

= > arr(3) is lower than arr(2). So Arr ( 3) has an advanced left-wing bound.

=> Push the indicator into the stack. st = { 0, 2, 3}.

For i = 4,

= > arr(4) is less than arr(stack top). So arr(4) is the advanced right bound of the current stack top.

= > Calculate the water stored in the same way as for i = 2. The base height is ~3.

=> Pop the stack top. So st = { 0, 2}.

= > Water stored in between when arr( 4) and arr( 2) are the bound = { min( arr( 4), arr( 2)) - arr( 3)} *(4 - 2 - 1) = 2.

= > arr(4) is less than arr(2).

= > Pop the stack. st = { 0}.

= > Water stored in between arr( 0) and arr(4)

when arr( 2) is the base height = { min( 3, 4) - 2} *( 4 - 0 - 1) = 3

= > arr(0) lower than arr(4). So pop stack. st = {}.

As there is no element left in the stack, push the indicator. st = { 4}.

= > Total water stored = 2 2 3 = 7.

So, the total quantum of water stored is 7.

Follow the steps mentioned below to apply the idea.

Loop through the indicators of the bar array.

For each bar, do the following:

Loop while the stack isn't empty and the current bar has a height less than the top bar of the stack.

Store the indicator of the top bar in pop_height and pop it from the stack.

Find the distance between the left bar( current top) of the popped bar and the current bar.

Find the minimal height between the top bar and the current bar.

The maximum amount of water that can be trapped is the distance *min_height.

The water trapped, including the popped bar, is( distance *min_height) minus (pop_height).

Add that to the answer.

Return the quantum entered as the total quantum of water.

Implementation

# Python implementation of the approach of using stack 
# Function for returning the maximum water that can be stored.
def maximum_Water(height): 
	# Stack for storing the indices of the bars of various heights. 
	stack = [] 
	# The length of the array is defined here.
	n = len(height) 
	# Variable for storing the final result.
	answer = 0
	# Loop through the each bar 
	for i in range(n): 
		# The bars are removed from the stack until the condition is met. 
		while(len(stack) != 0 and (height[stack[-1]] < height[i])): 
			pop_height = height[stack[-1]] 
			stack.pop() 
			if(len(stack) == 0): 
				break
			# Get the distance between the left and right boundary of the popped bar 
			distance = i - stack[-1] - 1
			# Calculate the minimum height 
			minimum_height = min(height[stack[-1]], height[i])-pop_height 
			answer += distance * minimum_height 
		# If the stack is either empty or the height of the current bar is less than or equal to the top bar of the stack 
		stack.append(i) 
	return answer
if __name__ == '__main__': 
	array = [0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1] 
	print("The maximum height of the water is:")
	print(maximum_Water(array)) 

Output:

Explanation

The law defines a characteristic maximum_Water that takes a table of integers representing the heights of bars as entered.

The characteristic initializes an empty stack stack and a variable maximum_water to store the most volume of water that may be stored.

The function iterates through every bar in the table of heights.

While the stack is not always empty, and the current bar is more advanced than the bar on the top of the stack, the specific does the posterior.

Pops the bar at the top of the stack.

Calculates the space among the left and right bars of the popped bar.

Calculates the minimal top among the left and right bars.

Adds the area of the water trapped some of the bars to the maximum_water.

The characteristic pushes the indicator of the contemporary bar onto the stack.

Eventually, the characteristic returns the maximum_water.

In easier terms, the law works with the useful resource of chancing heights of bars that can show water amongst them. The bars on the left and proper of each bar ought to be more advanced than the maximum bar so as for water to be trapped. The quantum of water that may be trapped is equal to the minimum peak among the 2 bars extended by means of the gap between them.

The law uses a stack to keep song of the bars that have been visible to date. The stack is exceptionally popped, indeed, as a bar is set up. This is more advanced than the bar on the zenith of the stack. This is due to the fact any bars that can be lower than the bar beneath the stack cannot bait any water with the ultramodernheight bar.

Approach 4(vertical checkup system)

The idea is as follows:

Still, it'll be the maximum possible height for any trapped rainwater. If max_height is the height of the altitudinous block,

And if, for each unit of height, we find the left wing and the rightmost boundary for that height, we can consider all the blocks in between to contain that quantum of water.

But this will also consider the height of the bars. So we've got to decrease that from the total water trapped.

This can be justified as follows: Say the sections for a certain height are{ i1, i2},{ i2, i3},...,{ ik- 1, ik}.

So, the water stored in between a single unit of height is the difference between the indicators.

= (i2 - i1 - 1)(i3 - i2 - 1)...(ik - ik- 1-1}) = ik - i1 -(k - 1), where k is the number of bars in between.

But as we're considering all the blocks in between the left and right boundaries, it also considers all the bars.

So, the trapped water for a single unit becomes( ik - i1).

Follow the illustration below for a better understanding.

Illustration

Consider array arr() = { 3, 0, 2, 0, 4}.

= 4, and the sum of all blocks is 2 3 4 = 9.

For height = 1,

> leftmost boundary = 0 and rightmost boundary = 4.

All blocks in between contain 1 meter of water.

= > So quantum of water trapped = (4 - 0) = 5

= > Total trapped water = 0 5 = 5

For height = 2

> leftmost boundary = 0 and rightmost boundary = 4.

> All blocks in between contain two heights of water.

> Before, we've considered water columns with height 1. So there's an increase of 1 unit in height.

= > So quantum of water trapped = (4 - 0) = 5

= > Total trapped water = 5/5 = 10

For height = 3,

> leftmost boundary = 0 and rightmost boundary = 4.

> All blocks in between contain three heights of water.

Before, we've considered water columns with a height of 2. So there's an increase of 1 unit in height.

= > So quantum of water trapped = (4 - 0) = 5

= > Total trapped water = 10 5 = 15

For height = 4

> leftmost boundary = 4 and rightmost boundary = 4.

All blocks in between contain 4 m of water.

Before, we've considered water columns with a height of 3. So there's an increase of 1 unit in height.

= > So quantum of water trapped = (4 - 4 1) = 1

= > Total trapped water = 15 1 = 16

So total water trapped = 16 minus total space taken by bars = 16 minus 9 = 7.

Follow the steps mentioned below to apply the idea.

Find the total number of blocks, i.e., the sum of the heights array, num_blocks.

Find the maximum height.

Store total water in a variable, aggregate = 0.

Keep two pointers, left = 0 and right = N-1, to store the left wing and the rightmost boundaries for each unit of height.

For each height, from 1 to max_height, do the following:

Find the left wing and the rightmost boundary for the current height.

As mentioned before, we can consider all the blocks in between these to have at least one unit of water.

Add this quantity of water to the total trapped water.

After the replication is over, abatenum_blocks are removed from the total, as we've considered them as water height during computation.

Implementation

Implementation of the above approach is as follows:

# Python code for the implementation of approach 4  using the horizontal scan method. 
def Water_trapped(array): 
	number_of_blocks = 0
	size = 0
	maximum_height = float('-inf') 
	# Finding the total number of blocks, maximum height, and length of the array.
	for height in array: 
		number_of_blocks += height 
		size += 1
		maximum_height = max(maximum_height, height) 
	# Total water, left pointer, and right pointer are initialized to 0 and size - 1 
	total = 0
	left_array = 0
	right_array = size - 1
	for i in range(1, maximum_height+1): 
		# Finding the leftmost point that is greater than the current row (i) 
		while array[left_array] < i: 
			left_array += 1
		# Finding the rightmost point that is greater than the current row (i) 
		while array[right_array] < i: 
			right_array -= 1
		# Water in this row = right_array - left_array + 1 
		total += (right_array - left_array + 1) 
	total -= number_of_blocks 
	return total 
#Driver code for the implementation. 
if __name__ == "__main__": 
	array = [0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1] 
	print("The maximum height of water is:")
	print(Water_trapped(array))

Output:

Explanation:

Python code to implement a "horizontally scanning" technique to determine how much water is trapped between blocks in a panorama represented by a set of elevated areas:

1. Job Definition:

The function `Water_trapped(array)` takes an array of lines representing the height of the blocks and returns the total amount of water trapped in these blocks.

2. Background:

Initialize variables like `number_of_blocks,' 'size,' size,` and'maximum_height.` - `number_of_blocks` continues the total (sum of the highest) range of blocks; 'size" stores the duration of the array; and'maximum_height` stores the maximum height of the blocks.

3. Repeat at a higher level.

The attribute iterates over every possible vertex from 1 to'maximum_height`.

4. Availability Scan:

For each height ` i', it scans vertically from left to right and appropriately to the left to find the left and right sides where the height of the sides is greater than or equal to 'i'. - This is accomplished while loops incrementing or decrementing the left and right directives (`left_array` and `right_array`) until the block with the highest maximum from or equal to `i' is referenced.

5. Caught water calculation:

For each `i', compute the trapped streams in that layer due to the difference between `right_array` and `left_array`, adding 1 (representing the current block). - This applies to all water bodies.

6. Last count:

By iterating through all elevations, the feature removes the total number of blocks from the calculated total water catch and excludes only the blocks from the calculation.

7. Results being published:

Eventually, the quality returns the heaviest water of the entire array.

Approach 5(Using Two Pointers)

Produce two pointers, one on the array's left side and one on its right. However, the total quantum of water trapped would depend on both the right-to-left and left-to-right directions if there's a block on the left side.

Algorithm

Produce and set left_pointer = 0, right_pointer = n-1, and ans = 0.

Produce two variables, left_maximum and right_maximum, and set them to 0.

While left_pointer< = right_pointer, keep covering the array and

If Arr(left_pointer)< Arr(right_pointer) and left_maximum> Arr(left_maximum),

addleft_maximum - Arr(left_pointer) to ans

Differently ifleft_maximum< Arr(left_pointer)

Update the left_maximum to Arr(left_pointer).

Increment of the left pointer by one

In an analogous way, if Arr(left_pointer)> Arr(right_pointer) and Arr(right_maximum) > Arr(right_pointer),

addright_maximum - Arr(right_maximum) to ans

Differently ifright_maximum< Arr(right_maximum)

Update the right_maximum to Arr(right_pointer).

Increment the pointer by one.

Publish the article.

Implementation:

def trap_rainwater(Arr):
   k, l = 0, len(Arr) - 1
   left_maximum, right_maximum = Arr[k], Arr[l]
   ans = 0
   while k < l:
       left_maximum = max(left_maximum, Arr[k])
       right_maximum = max(right_maximum, Arr[l])
       if left_maximum < right_maximum:
           ans += left_maximum - Arr[k]
           k += 1	
       else:
           ans += right_maximum - Arr[l]
           l -= 1
   return ans
Arr=[1, 2, 4, 5, 1, 1, 2]
print("The highest water in array are:")
print(trap_rainwater(Arr))

Output: