 GeeksforGeeks App
Open App Browser
Continue

# Minimum cost to remove all 1s from given Binary String as per given conditions

Given a binary sequence of 1‘s and 0‘s. Our task is to remove all 1s from the sequence in minimum cost by below operations.

• Remove an element from the left end (i.e., remove s) which costs 1 coin.
• Remove an element from the right end (i.e., remove s[s.length – 1]) which costs 1 coin.
• Remove an element from anywhere in the sequence which costs 2 coins.

Return the minimum cost to remove all the 1s from the sequence.

Examples:

Input: s = “1100101”
Output: 5
Explanation:
Remove left most “1100101″ in cost of 1 coin, new s = “100101”
Remove left most “100101″ in cost of 1 coin, new s = “00101”
Remove right most “00101” in cost of 1 coin, new s = “0010”
Remove middle 1 (“0010″) in cost of 2 coin, new s = “000”.
So total 5 coins are required

Input: s = “0010”
Output: 2
Explanation: Remove middle 1 (“0010”) in cost of 2 coin, new s = “000”

Approach:  The idea is to use DP with sliding window. Use an array dp[N] where dp[i] stores the minimum coin to remove all 1s from index i to n-1, where we can only remove from right. Follow the below steps.

• Loop from the rightmost index. So, for any index i the transition is as follows:
• If it’s a ‘0’ then dp[i]=dp[i+1]
• If it’s a ‘1’ then we have two options – either consider this element as a middle one and add 2 to dp[i+1] or remove all elements. Hence, dp[i]=min(dp[i+1]+2, n-i)
• Now,  also remove elements from left. So,  loop over the vector.
• When we reach any index i, we will consider that we have removed all elements from 0 to i from the leftside.
• So, our time for that index will be i+1+dp[i+1].
• Since, we have removed all elements until i, we need to just consider elements from i+1 and hence we are adding the dp[i+1] to our i+1.

Below is the code implementation:

## C++

 `// C++ program for find the minimum cost``// to remove all 1's from the given binary string``#include ``using` `namespace` `std;` `// Function to find minimum cost``int` `minimumCoin(string s)``{``    ``int` `n = s.length();``    ``vector<``int``> dp(n, 0);``    ``if` `(s[n - 1] == ``'0'``) {``        ``dp[n - 1] = 0;``    ``}``    ``else` `{``        ``dp[n - 1] = 1;``    ``}``    ``for` `(``int` `i = n - 2; i >= 0; i--) {``        ``if` `(s[i] == ``'0'``)``            ``dp[i] = dp[i + 1];``        ``if` `(s[i] == ``'1'``) {` `            ``// consider current index to``            ``// be a middle one and remove``            ``dp[i] = 2 + dp[i + 1];` `            ``// or remove all to the right``            ``dp[i] = min(dp[i], n - i);``        ``}``    ``}` `    ``// now go from left to right``    ``int` `ans = dp;``    ``for` `(``int` `i = 0; i < n - 1; i++) {` `        ``// cost of removing all``        ``// from left and dp[i+1]``        ``ans = min(ans, i + 1 + dp[i + 1]);``    ``}` `    ``// taking overall minimum``    ``ans = min(ans, n);``    ``return` `ans;``}` `// Driver function``int` `main()``{` `    ``string str = ``"1001001"``;``    ``int` `coins = minimumCoin(str);``    ``cout << coins;``    ``return` `0;``}`

## Java

 `//Java program for find the minimum cost``// to remove all 1's from the given binary string``import` `java.io.*;` `class` `GFG {` `  ``// Function to find minimum cost``  ``static` `int` `minimumCoin(String s)``  ``{``    ``int` `n = s.length();``    ``int` `dp[] = ``new` `int``[n];``    ``if` `(s.charAt(n - ``1``) == ``'0'``) {``      ``dp[n - ``1``] = ``0``;``    ``}``    ``else` `{``      ``dp[n - ``1``] = ``1``;``    ``}``    ``for` `(``int` `i = n - ``2``; i >= ``0``; i--) {``      ``if` `(s.charAt(i) == ``'0'``)``        ``dp[i] = dp[i + ``1``];``      ``if` `(s.charAt(i) == ``'1'``) {` `        ``// consider current index to``        ``// be a middle one and remove``        ``dp[i] = ``2` `+ dp[i + ``1``];` `        ``// or remove all to the right``        ``dp[i] = Math.min(dp[i], n - i);``      ``}``    ``}` `    ``// now go from left to right``    ``int` `ans = dp[``0``];``    ``for` `(``int` `i = ``0``; i < n - ``1``; i++) {` `      ``// cost of removing all``      ``// from left and dp[i+1]``      ``ans = Math.min(ans, i + ``1` `+ dp[i + ``1``]);``    ``}` `    ``// taking overall minimum``    ``ans = Math.min(ans, n);``    ``return` `ans;``  ``}` `  ``// Driver function``  ``public` `static` `void` `main (String[] args) {``    ``String str = ``"1001001"``;``    ``int` `coins = minimumCoin(str);``    ``System.out.println(coins);``  ``}``}` `// This code is contributed by hrithikgarg03188.`

## Python3

 `# Python code for the above approach` `# Function to find minimum cost``def` `minimumCoin(s):` `    ``n ``=` `len``(s)``    ``dp ``=` `[``0``]``*``n``    ``if` `(s[n ``-` `1``] ``=``=` `'0'``):``        ``dp[n ``-` `1``] ``=` `0` `    ``else``:``        ``dp[n ``-` `1``] ``=` `1` `    ``for` `i ``in` `range``(n``-``2``, ``-``1``, ``-``1``):``        ``if` `s[i] ``=``=` `'0'``:``            ``dp[i] ``=` `dp[i ``+` `1``]``        ``if` `s[i] ``=``=` `'1'``:` `            ``# consider current index to``            ``# be a middle one and remove``            ``dp[i] ``=` `2` `+` `dp[i ``+` `1``]` `            ``# or remove all to the right``            ``dp[i] ``=` `min``(dp[i], n ``-` `i)` `    ``# now go from left to right``    ``ans ``=` `dp[``0``]``    ``for` `i ``in` `range``(``0``, n``-``1``):` `        ``# cost of removing all``        ``# from left and dp[i+1]``        ``ans ``=` `min``(ans, i ``+` `1` `+` `dp[i ``+` `1``])` `    ``# taking overall minimum``    ``ans ``=` `min``(ans, n)``    ``return` `ans` `# Driver function``str` `=` `"1001001"``coins ``=` `minimumCoin(``str``)``print``(coins)` `# This code is contributed by Potta Lokesh`

## C#

 `// C# program for find the minimum cost``// to remove all 1's from the given binary string``using` `System;` `class` `GFG {` `  ``// Function to find minimum cost``  ``static` `int` `minimumCoin(``string` `s)``  ``{``    ``int` `n = s.Length;``    ``int``[] dp = ``new` `int``[n];``    ``if` `(s[n - 1] == ``'0'``) {``      ``dp[n - 1] = 0;``    ``}``    ``else` `{``      ``dp[n - 1] = 1;``    ``}``    ``for` `(``int` `i = n - 2; i >= 0; i--) {``      ``if` `(s[i] == ``'0'``)``        ``dp[i] = dp[i + 1];``      ``if` `(s[i] == ``'1'``) {` `        ``// consider current index to``        ``// be a middle one and remove``        ``dp[i] = 2 + dp[i + 1];` `        ``// or remove all to the right``        ``dp[i] = Math.Min(dp[i], n - i);``      ``}``    ``}` `    ``// now go from left to right``    ``int` `ans = dp;``    ``for` `(``int` `i = 0; i < n - 1; i++) {` `      ``// cost of removing all``      ``// from left and dp[i+1]``      ``ans = Math.Min(ans, i + 1 + dp[i + 1]);``    ``}` `    ``// taking overall minimum``    ``ans = Math.Min(ans, n);``    ``return` `ans;``  ``}` `  ``// Driver function``  ``public` `static` `void` `Main()``  ``{``    ``string` `str = ``"1001001"``;``    ``int` `coins = minimumCoin(str);``    ``Console.Write(coins);``  ``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`4`

Time complexity: O(n)
Space complexity: O(n)

My Personal Notes arrow_drop_up