Binary String Reduction

Question

you are given a binary string (only 0's and 1's) s of length n.
you want to convert s into an empty string by performing the following operation the least number of times.

In one Operation, you can remove an alternating subsequence from s without changing the order of the remaining characters.

your task is to determine the minimum number of operations required to convert s into an empty string.

Note:

An alternating subsequence of a string s is defined as follows

Any subsequence of length 1
if length greater than 1, and no two consecutive elements being equal. For Example, '0101', '101', '0' are alternating sequences, while '100' and '01011' are not.

Constraints:

1 <= T <= 10
1 <= n <= 10^6

Sample Input:

1
10
0100100111

Sample Output:

Explanation:

remove subsequence "010101" from "0100100111" to make it "0011"

remove subsequence "01" from "0011" to make it "01"

finally, remove subsequence "01" from "01" to make it "" (empty binary string)

This is a great question. It has a simple linear time solution, but I thought it was pretty tough to figure that out. I'd be happy to answer it if you edit it to remove all references to the employer -- I don't want to mess with their hiring process. — Matt Timmermans, Nov 23 '20 at 14:37

score 0 · Accepted Answer · answered Nov 24 '20 at 02:07

Imagine that for some string x, you know that you can erase it using m operations that end in '0' and n operations that end in '1', for a total of (m+n) operations. We will write this (m,n). This is not necessarily the best result, but it is a result.

Now, what do you know about the string x0?

If n>1, then you could add a zero to one of those 1-ending operations, turning it into a zero-ending operation, so you could clear x0 in (m+1,n-1) operations.

And of course you could always just add a new 0-ending operation so you could clear x0 in (m+1,n) operations.

Similarly, you could clear x1 in (m,n+1) operations, or (m-1,n+1) if m>0.

Obviously there's only one way to clear the empty string, and that's with (0,0) operations, so working from the start to the end, you can calculate all of the various (m,n) possibilities to clear each prefix until you get to the end, and then the one with the smallest sum is your answer. That would be an O(n²) algorithm.

But, there is no case in which choosing (m+1,n) instead of (m+1,n-1) will enable you to use fewer operations overall. Similarly, there is no case in which choosing (m, n+1) is better than (m-1,n+1).

So, instead of worrying about both possible choices at each position, we can make the single best choice deterministically, depending on whether the next character is 0 or 1:

Starting with x="" and (m,n) = (0,0):

When the next char is 0, then x <- x+"0" and (m,n) <- (m+1,max(n-1,0))
When the next char is 1, then x <- x+"1" and (m,n) <- (max(m-1,0),n+1)

When you get to the end of the string, m+n is the fewest number of operations that can clear it.

Or, in pseudocode:

m = 0; n = 0;
for (char in string) {
    if (char == 0') {
        m = m+1;
        n = max(n-1,0);
    } else {
        m = max(m-1,0);
        n = n+1;
    }
}
return m+n;

Easy peasy.

for input '11111', the output should be 3 right? but this way am getting 5 as an output. I tried this way using a stack pushing the elements into it(like checking if there's any alternating element on top, if yes popping it else push the element). that way storing the maximum size of the stack to return as an output but this cleared only two test cases. — Chakradhar, Nov 24 '20 at 06:23
The only alternating sequence you can remove from `11111` is `1`. You have to do that 5 times. — Matt Timmermans, Nov 24 '20 at 12:45
I thought we can remove the alternating 1's in the first operation (removing 1's at position 0, 2, 4). for the second operation to apply, we are left with only '11' which we can remove each in 2 operations. so a total of 3 operations is required to make it empty. is it right? if you don't mind can you tell me whether your pseudo code passed all the test cases? — Chakradhar, Nov 24 '20 at 13:24
No, they don't mean characters at alternating positions. That would make the problem much easier, since the content of the string wouldn't matter at all. The subsequence you remove needs to have alternating 0s and 1s — Matt Timmermans, Nov 24 '20 at 13:30

Binary String Reduction

1 Answers1