# Minimum characters required to be removed to sort binary string in ascending order – Set 2

Given binary string **str** of size **N**, the task is to remove the minimum number of characters from the given binary string such that the characters in the remaining string are in sorted order.

**Examples:**

Input:str = “1000101”Output:2Explanation:Removal of the first two occurrences of ‘1’ modifies the string to “00001”, which is a sorted order. The string can also be made “00011” by performing 2 removals. Therefore, the minimum count of characters to be removed is 2.

Input:str = “001111”Output:0Explanation:The string is already sorted. Therefore, the minimum count of character to be removed is 0.

**Last Occurrence Approach:** The optimized approach in linear time and constant space is discussed in Set 1 of this article. Here, we are discussing the Dynamic Programming Approach.

**Dynamic Programming Approach:** This problem can be solved using dynamic programming by observing the following facts, that if **K** deletion is required to make the string sorted till i^{th} index and

- Case1:
S[i+1] = 1then minimum number of deletions required to make string sorted till(i+1)thindex will also beKas appending1to a sorted string will keep string sorted so no more deletion required.- Case2:
S[i + 1] = 0then we have two way to make string sorted till(i+1)thindex that are

- either delete all
1’sbefore(i+1)thindex, or- delete current
0.Minimum number of deletion to make string valid till (i+1)th index will be minimum of

(numbers of 1’s before (i+1)th index , K+1).

Follow the steps below to solve the problem:

- Initialize the variables
**count1**as**0**and**N**is the length of the string**s****.** - Initialize the vector
**dp[n+1]**with values**0.** - Iterate over the range
**[0, n)**using the variable**i**and perform the following tasks:- If
**s[i]**equals**0,**then set**dp[i+1]**as the minimum of**count1**or**1 + dp[i].** - Else, set
**dp[i+1]**as**dp[i]**and increase the value of**count1**by**1.**

- If
- After performing the above steps, print the value of
**dp[n]**as the answer.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find the minimum number` `// of deletions to make` `// the string sorted` `int` `minDeletions(string s)` `{` ` ` `int` `n = s.size();` ` ` `// dp[i+1] stores minimum number of` ` ` `// deletion to make` ` ` `// substring(0, i) valid` ` ` `vector<` `int` `> dp(n + 1, 0);` ` ` `int` `count1 = 0;` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `if` `(s[i] == ` `'0'` `) {` ` ` `// Case 1: remove current 0` ` ` `// Case 2: keep current 0` ` ` `// then delete all 1 before it` ` ` `dp[i + 1] = min(count1,` ` ` `1 + dp[i]);` ` ` `}` ` ` `else` `{` ` ` `// Appending 1 is always valid` ` ` `// if substring(0, i) is sorted` ` ` `dp[i + 1] = dp[i];` ` ` `count1++;` ` ` `}` ` ` `}` ` ` `return` `dp[n];` `}` `// Driver Code` `int` `main()` `{` ` ` `string s = ` `"00101101"` `;` ` ` `cout << minDeletions(s);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.util.*;` `public` `class` `GFG` `{` ` ` `// Function to find the minimum number` `// of deletions to make` `// the string sorted` `static` `int` `minDeletions(String s)` `{` ` ` `int` `n = s.length();` ` ` `// dp[i+1] stores minimum number of` ` ` `// deletion to make` ` ` `// substring(0, i) valid` ` ` `int` `[]dp = ` `new` `int` `[n + ` `1` `];` ` ` `for` `(` `int` `i = ` `0` `; i < n + ` `1` `; i++) {` ` ` `dp[i] = ` `0` `;` ` ` `}` ` ` `int` `count1 = ` `0` `;` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) {` ` ` `if` `(s.charAt(i) == ` `'0'` `) {` ` ` `// Case 1: remove current 0` ` ` `// Case 2: keep current 0` ` ` `// then delete all 1 before it` ` ` `dp[i + ` `1` `] = Math.min(count1,` ` ` `1` `+ dp[i]);` ` ` `}` ` ` `else` `{` ` ` `// Appending 1 is always valid` ` ` `// if substring(0, i) is sorted` ` ` `dp[i + ` `1` `] = dp[i];` ` ` `count1++;` ` ` `}` ` ` `}` ` ` `return` `dp[n];` `}` `// Driver Code` `public` `static` `void` `main(String args[])` `{` ` ` `String s = ` `"00101101"` `;` ` ` `System.out.println(minDeletions(s));` `}` `}` `// This code is contributed by Samim Hossain Mondal.` |

## Python3

`# Python code for the above approach` `# Function to find the minimum number` `# of deletions to make` `# the string sorted` `def` `minDeletions(s):` ` ` `n ` `=` `len` `(s)` ` ` `# dp[i+1] stores minimum number of` ` ` `# deletion to make` ` ` `# substring(0, i) valid` ` ` `dp ` `=` `[` `0` `] ` `*` `(n ` `+` `1` `)` ` ` `count1 ` `=` `0` ` ` `for` `i ` `in` `range` `(n):` ` ` `if` `(s[i] ` `=` `=` `'0'` `):` ` ` `# Case 1: remove current 0` ` ` `# Case 2: keep current 0` ` ` `# then delete all 1 before it` ` ` `dp[i ` `+` `1` `] ` `=` `min` `(count1, ` `1` `+` `dp[i])` ` ` `else` `:` ` ` `# Appending 1 is always valid` ` ` `# if substring(0, i) is sorted` ` ` `dp[i ` `+` `1` `] ` `=` `dp[i]` ` ` `count1 ` `+` `=` `1` ` ` `return` `dp[n]` `# Driver Code` `s ` `=` `"00101101"` `print` `(minDeletions(s))` `# This code is contributed by Saurabh Jaiswal` |

## C#

`// C# program for the above approach` `using` `System;` `public` `class` `GFG` `{` ` ` `// Function to find the minimum number` ` ` `// of deletions to make` ` ` `// the string sorted` ` ` `static` `int` `minDeletions(` `string` `s)` ` ` `{` ` ` `int` `n = s.Length;` ` ` `// dp[i+1] stores minimum number of` ` ` `// deletion to make` ` ` `// substring(0, i) valid` ` ` `int` `[] dp = ` `new` `int` `[n + 1];` ` ` `for` `(` `int` `i = 0; i < n + 1; i++)` ` ` `{` ` ` `dp[i] = 0;` ` ` `}` ` ` `int` `count1 = 0;` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` `if` `(s[i] == ` `'0'` `)` ` ` `{` ` ` `// Case 1: remove current 0` ` ` `// Case 2: keep current 0` ` ` `// then delete all 1 before it` ` ` `dp[i + 1] = Math.Min(count1,` ` ` `1 + dp[i]);` ` ` `}` ` ` `else` ` ` `{` ` ` `// Appending 1 is always valid` ` ` `// if substring(0, i) is sorted` ` ` `dp[i + 1] = dp[i];` ` ` `count1++;` ` ` `}` ` ` `}` ` ` `return` `dp[n];` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `string` `s = ` `"00101101"` `;` ` ` `Console.Write(minDeletions(s));` ` ` `}` `}` `// This code is contributed by Saurabh Jaiswal` |

## Javascript

`<script>` ` ` `// JavaScript code for the above approach` ` ` `// Function to find the minimum number` ` ` `// of deletions to make` ` ` `// the string sorted` ` ` `function` `minDeletions(s) {` ` ` `let n = s.length;` ` ` `// dp[i+1] stores minimum number of` ` ` `// deletion to make` ` ` `// substring(0, i) valid` ` ` `let dp = ` `new` `Array(n + 1).fill(0);` ` ` `let count1 = 0;` ` ` `for` `(let i = 0; i < n; i++) {` ` ` `if` `(s[i] == ` `'0'` `) {` ` ` `// Case 1: remove current 0` ` ` `// Case 2: keep current 0` ` ` `// then delete all 1 before it` ` ` `dp[i + 1] = Math.min(count1,` ` ` `1 + dp[i]);` ` ` `}` ` ` `else` `{` ` ` `// Appending 1 is always valid` ` ` `// if substring(0, i) is sorted` ` ` `dp[i + 1] = dp[i];` ` ` `count1++;` ` ` `}` ` ` `}` ` ` `return` `dp[n];` ` ` `}` ` ` `// Driver Code` ` ` `let s = ` `"00101101"` `;` ` ` `document.write(minDeletions(s));` `// This code is contributed by Potta Lokesh` ` ` `</script>` |

**Output**

2

**Time Complexity:** O(N)**Auxiliary Space:** O(N)