Collect all coins in minimum number of steps

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.

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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(N²)

C++

// C++ program to find minimum number of 
// steps to collect stack of coins 
#include <bits/stdc++.h> 
using namespace std; 
  
// recursive method to collect coins from 
// height array l to r, with height h already 
// collected 
int minStepsRecur(int height[], int l, int r, int h) 
{ 
    // if l is more than r, no steps needed 
    if (l >= r) 
        return 0; 
  
    // loop over heights to get minimum height 
    // index 
    int m = l; 
    for (int i = l; i < r; i++) 
        if (height[i] < height[m]) 
            m = i; 
  
    /* choose minimum from, 
        1) collecting coins using all vertical 
        lines (total r - l) 
        2) collecting coins using lower horizontal 
        lines and recursively on left and right 
        segments */
    return min(r - l, 
               minStepsRecur(height, l, m, height[m]) +  
               minStepsRecur(height, m + 1, r, height[m]) +  
               height[m] - h); 
} 
  
// method returns minimum number of step to 
// collect coin from stack, with height in 
// height[] array 
int minSteps(int height[], int N) 
{ 
    return minStepsRecur(height, 0, N, 0); 
} 
  
// Driver code to test above methods 
int main() 
{ 
    int height[] = { 2, 1, 2, 5, 1 }; 
    int N = sizeof(height) / sizeof(int); 
  
    cout << minSteps(height, N) << endl; 
    return 0; 
} 

Java

// Java Code to Collect all coins in 
// minimum number of steps 
import java.util.*; 
  
class GFG { 
  
    // recursive method to collect coins from 
    // height array l to r, with height h already 
    // collected 
    public static int minStepsRecur(int height[], int l, 
                                           int r, int h) 
    { 
        // if l is more than r, no steps needed 
        if (l >= r) 
            return 0; 
  
        // loop over heights to get minimum height 
        // index 
        int m = l; 
        for (int i = l; i < r; i++) 
            if (height[i] < height[m]) 
                m = i; 
  
        /* choose minimum from, 
            1) collecting coins using all vertical 
            lines (total r - l) 
            2) collecting coins using lower horizontal 
            lines and recursively on left and right 
            segments */
        return Math.min(r - l, 
                        minStepsRecur(height, l, m, height[m]) +  
                        minStepsRecur(height, m + 1, r, height[m]) + 
                        height[m] - h); 
    } 
  
    // method returns minimum number of step to 
    // collect coin from stack, with height in 
    // height[] array 
    public static int minSteps(int height[], int N) 
    { 
        return minStepsRecur(height, 0, N, 0); 
    } 
  
    /* Driver program to test above function */
    public static void main(String[] args) 
    { 
  
        int height[] = { 2, 1, 2, 5, 1 }; 
        int N = height.length; 
  
        System.out.println(minSteps(height, N)); 
    } 
} 
  
// This code is contributed by Arnav Kr. Mandal. 

Python 3

# Python 3 program to find  
# minimum number of steps  
# to collect stack of coins 
  
# recursive method to collect  
# coins from height array l to  
# r, with height h already 
# collected 
def minStepsRecur(height, l, r, h): 
  
    # if l is more than r, 
    # no steps needed 
    if l >= r: 
        return 0; 
  
    # loop over heights to  
    # get minimum height index 
    m = l 
    for i in range(l, r): 
        if height[i] < height[m]: 
            m = i 
  
    # choose minimum from, 
    # 1) collecting coins using  
    # all vertical lines (total r - l) 
    # 2) collecting coins using  
    # lower horizontal lines and  
    # recursively on left and  
    # right segments  
    return min(r - l, 
            minStepsRecur(height, l, m, height[m]) +
            minStepsRecur(height, m + 1, r, height[m]) +
            height[m] - h) 
  
# method returns minimum number 
# of step to collect coin from  
# stack, with height in height[] array 
def minSteps(height, N): 
    return minStepsRecur(height, 0, N, 0) 
  
# Driver code  
height = [ 2, 1, 2, 5, 1 ] 
N = len(height) 
print(minSteps(height, N)) 
  
# This code is contributed 
# by ChitraNayal 

C#

// C# Code to Collect all coins in 
// minimum number of steps 
using System; 
  
class GFG { 
  
    // recursive method to collect coins from 
    // height array l to r, with height h already 
    // collected 
    public static int minStepsRecur(int[] height, int l, 
                                           int r, int h) 
    { 
        // if l is more than r, no steps needed 
        if (l >= r) 
            return 0; 
  
        // loop over heights to 
        // get minimum height index 
        int m = l; 
        for (int i = l; i < r; i++) 
            if (height[i] < height[m]) 
                m = i; 
  
        /* choose minimum from, 
            1) collecting coins using all vertical 
            lines (total r - l) 
            2) collecting coins using lower horizontal 
            lines and recursively on left and right 
            segments */
        return Math.Min(r - l, 
                        minStepsRecur(height, l, m, height[m]) +  
                        minStepsRecur(height, m + 1, r, height[m]) + 
                        height[m] - h); 
    } 
  
    // method returns minimum number of step to 
    // collect coin from stack, with height in 
    // height[] array 
    public static int minSteps(int[] height, int N) 
    { 
        return minStepsRecur(height, 0, N, 0); 
    } 
  
    /* Driver program to test above function */
    public static void Main() 
    { 
        int[] height = { 2, 1, 2, 5, 1 }; 
        int N = height.Length; 
  
        Console.Write(minSteps(height, N)); 
    } 
} 
  
// This code is contributed by nitin mittal 

PHP

<?php 
// PHP program to find minimum number of 
// steps to collect stack of coins 
  
// recursive method to collect 
// coins from height array l to  
// r, with height h already 
// collected 
function minStepsRecur($height, $l, 
                            $r, $h) 
{ 
      
    // if l is more than r, 
    // no steps needed 
    if ($l >= $r) 
        return 0; 
  
    // loop over heights to 
    // get minimum height 
    // index 
    $m = $l; 
    for ($i = $l; $i < $r; $i++) 
        if ($height[$i] < $height[$m]) 
            $m = $i; 
  
    /* choose minimum from, 
        1) collecting coins using  
           all vertical lines  
           (total r - l) 
        2) collecting coins using  
           lower horizontal lines  
           and recursively on left 
           and right segments */
    return min($r - $l, 
           minStepsRecur($height, $l, $m, $height[$m]) +  
           minStepsRecur($height, $m + 1, $r, $height[$m]) +  
           $height[$m] - $h); 
} 
  
// method returns minimum number of step to 
// collect coin from stack, with height in 
// height[] array 
function minSteps($height, $N) 
{ 
    return minStepsRecur($height, 0, $N, 0); 
} 
  
    // Driver Code 
    $height = array(2, 1, 2, 5, 1); 
    $N = sizeof($height); 
  
    echo minSteps($height, $N) ; 
      
// This code is contributed by nitin mittal. 
?> 

Output:

This article is contributed by Utkarsh Trivedi. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

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

Sep	OCT	Nov
	28
2019	2020	2021

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

C++

Java

Python 3

C#

PHP

Recommended Posts: