Collect all coins in minimum number of steps
Last Updated :
10 Apr, 2023
Given many stacks of coins which are arranged adjacently. We need to collect all these coins in the minimum number of steps where in one step we can collect one horizontal line of coins or vertical line of coins and collected coins should be continuous.
Examples :
Input : height[] = [2 1 2 5 1]
Each value of this array corresponds to
the height of stack that is we are given
five stack of coins, where in first stack
2 coins are there then in second stack
1 coin is there and so on.
Output : 4
We can collect all above coins in 4 steps
which are shown in below diagram.
Each step is shown by different color.
First, we have collected last horizontal
line of coins after which stacks remains
as [1 0 1 4 0] after that, another horizontal
line of coins is collected from stack 3
and 4 then a vertical line from stack 4
and at the end a horizontal line from
stack 1. Total steps are 4.
We can solve this problem using divide and conquer method. We can see that it is always beneficial to remove horizontal lines from below. Suppose we are working on stacks from l index to r index in a recursion step, each time we will choose minimum height, remove those many horizontal lines after which stack will be broken into two parts, l to minimum and minimum +1 till r and we will call recursively in those subarrays. Another thing is we can also collect coins using vertical lines so we will choose minimum between the result of recursive calls and (r – l) because using (r – l) vertical lines we can always collect all coins.
As each time we are calling each subarray and finding minimum of that, total time complexity of the solution will be O(N2)
C++
#include <bits/stdc++.h>
using namespace std;
int minStepsRecur(int height[], int l, int r, int h)
{
if (l >= r)
return 0;
int m = l;
for (int i = l; i < r; i++)
if (height[i] < height[m])
m = i;
return min(r - l,
minStepsRecur(height, l, m, height[m]) +
minStepsRecur(height, m + 1, r, height[m]) +
height[m] - h);
}
int minSteps(int height[], int N)
{
return minStepsRecur(height, 0, N, 0);
}
int main()
{
int height[] = { 2, 1, 2, 5, 1 };
int N = sizeof(height) / sizeof(int);
cout << minSteps(height, N) << endl;
return 0;
}
|
Java
import java.util.*;
class GFG {
public static int minStepsRecur(int height[], int l,
int r, int h)
{
if (l >= r)
return 0;
int m = l;
for (int i = l; i < r; i++)
if (height[i] < height[m])
m = i;
return Math.min(r - l,
minStepsRecur(height, l, m, height[m]) +
minStepsRecur(height, m + 1, r, height[m]) +
height[m] - h);
}
public static int minSteps(int height[], int N)
{
return minStepsRecur(height, 0, N, 0);
}
public static void main(String[] args)
{
int height[] = { 2, 1, 2, 5, 1 };
int N = height.length;
System.out.println(minSteps(height, N));
}
}
|
Python 3
def minStepsRecur(height, l, r, h):
if l >= r:
return 0;
m = l
for i in range(l, r):
if height[i] < height[m]:
m = i
return min(r - l,
minStepsRecur(height, l, m, height[m]) +
minStepsRecur(height, m + 1, r, height[m]) +
height[m] - h)
def minSteps(height, N):
return minStepsRecur(height, 0, N, 0)
height = [ 2, 1, 2, 5, 1 ]
N = len(height)
print(minSteps(height, N))
|
C#
using System;
class GFG {
public static int minStepsRecur(int[] height, int l,
int r, int h)
{
if (l >= r)
return 0;
int m = l;
for (int i = l; i < r; i++)
if (height[i] < height[m])
m = i;
return Math.Min(r - l,
minStepsRecur(height, l, m, height[m]) +
minStepsRecur(height, m + 1, r, height[m]) +
height[m] - h);
}
public static int minSteps(int[] height, int N)
{
return minStepsRecur(height, 0, N, 0);
}
public static void Main()
{
int[] height = { 2, 1, 2, 5, 1 };
int N = height.Length;
Console.Write(minSteps(height, N));
}
}
|
PHP
<?php
function minStepsRecur($height, $l,
$r, $h)
{
if ($l >= $r)
return 0;
$m = $l;
for ($i = $l; $i < $r; $i++)
if ($height[$i] < $height[$m])
$m = $i;
return min($r - $l,
minStepsRecur($height, $l, $m, $height[$m]) +
minStepsRecur($height, $m + 1, $r, $height[$m]) +
$height[$m] - $h);
}
function minSteps($height, $N)
{
return minStepsRecur($height, 0, $N, 0);
}
$height = array(2, 1, 2, 5, 1);
$N = sizeof($height);
echo minSteps($height, $N) ;
?>
|
Javascript
<script>
function minStepsRecur(height,l,r,h)
{
if (l >= r)
return 0;
let m = l;
for (let i = l; i < r; i++)
if (height[i] < height[m])
m = i;
return Math.min(r - l,
minStepsRecur(height, l, m, height[m]) +
minStepsRecur(height, m + 1, r, height[m]) +
height[m] - h);
}
function minSteps(height,N)
{
return minStepsRecur(height, 0, N, 0);
}
let height=[2, 1, 2, 5, 1 ];
let N = height.length;
document.write(minSteps(height, N));
</script>
|
Output:
4
Time complexity: The time complexity of this algorithm is O(N^2), where N is the number of elements in the height array.
Space complexity: The space complexity of this algorithm is O(N) due to the recursive calls that are made on the height array.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...