Minimum substring reversals required to make given Binary String alternating

• Last Updated : 01 Jun, 2021

Given a binary string S of length N, the task is to count the minimum number substrings of S that is required to be reversed to make the string S alternating. If it is not possible to make string alternating, then print “-1”.

Examples:

Input: S = “10001110”
Output: 2
Explanation:
In the first operation, reversing the substring {S, .., S} modifies the string to “10110010”.
In the second operation, reversing the substring {S, .. S}modifies the string to “10101010”, which is alternating.

Input: S = “100001”
Output: -1
Explanation: Not possible to obtain an alternating binary string.

Approach: The idea is based on the observation that when a substring s[L, R] is reversed, then no more than two pairs s[L – 1], s[L] and s[R], S[R + 1] are changed. Moreover, one pair should be a consecutive pair of 00 and the other 11. So, the minimum number of operations can be obtained by pairing 00 with 11 or with the left/right border of S. Thus, the required number of operations is half of the number of consecutive pairs of the same character. Follow the steps below to solve the problem:

Below is the implementation of the above approach:

C++

 // C++ program for the above approach#include using namespace std; // Function to count the minimum number// of substrings required to be reversed// to make the string S alternatingint minimumReverse(string s, int n){    // Store count of consecutive pairs    int k = 0 , l = 0 ;     // Stores the count of 1s and 0s    int sum1 = 0, sum0 = 0;     // Traverse through the string    for (int i = 1; i < n; i++) {         if (s[i] == '1')             // Increment 1s count            sum1++;        else             // Increment 0s count            sum0++;         // Increment K if consecutive        // same elements are found        if (s[i] == s[i - 1]&& s[i] == '0')            k++;      else if( s[i] == s[i - 1]&& s[i] == '1')        l++;    }       // Increment 1s count    if(s=='1')           sum1++;    else  // Increment 0s count       sum0++;     // Check if it is possible or not    if (abs(sum1 - sum0) > 1)        return -1;     // Otherwise, print the number    // of required operations    return max(k , l );} // Driver Codeint main(){    string S = "10001";    int N = S.size();     // Function Call    cout << minimumReverse(S, N);     return 0;}

Java

 // Java program for the above approachimport java.util.*;import java.lang.*; class GFG{   // Function to count the minimum number  // of substrings required to be reversed  // to make the string S alternating  static int minimumReverse(String s, int n)  {     // Store count of consecutive pairs    int k = 0 , l = 0 ;     // Stores the count of 1s and 0s    int sum1 = 0, sum0 = 0;     // Traverse through the string    for (int i = 1; i < n; i++)    {       if (s.charAt(i) == '1')         // Increment 1s count        sum1++;      else         // Increment 0s count        sum0++;       // Increment K if consecutive      // same elements are found      if (s.charAt(i) == s.charAt(i - 1) && s.charAt(i) == '0')        k++;      else if( s.charAt(i) == s.charAt(i - 1) && s.charAt(i) == '1')        l++;    }     // Increment 1s count    if(s.charAt(0)=='1')          sum1++;    else  // Increment 0s count      sum0++;     // Check if it is possible or not    if (Math.abs(sum1 - sum0) > 1)      return -1;     // Otherwise, print the number    // of required operations    return Math.max(k , l);  }   // Driver code  public static void main (String[] args)  {    String S = "10001";    int N = S.length();     // Function Call    System.out.print(minimumReverse(S, N));   }} // This code is contributed by offbeat

Python3

 # Python program for the above approach # Function to count the minimum number# of substrings required to be reversed# to make the string S alternatingdef minimumReverse(s, n):       # Store count of consecutive pairs    k = 0;    l = 0;     # Stores the count of 1s and 0s    sum1 = 0;    sum0 = 0;     # Traverse through the string    for i in range(1, n):        if (s[i] == '1'):             # Increment 1s count            sum1 += 1;        else:             # Increment 0s count            sum0 += 1;         # Increment K if consecutive        # same elements are found        if (s[i] == s[i - 1] and s[i] == '0'):            k += 1;        elif (s[i] == s[i - 1] and s[i] == '1'):            l += 1;     # Increment 1s count    if (s == '1'):        sum1 += 1;    else:  # Increment 0s count        sum0 += 1;     # Check if it is possible or not    if (abs(sum1 - sum0) > 1):        return -1;     # Otherwise, print the number    # of required operations    return max(k, l); # Driver codeif __name__ == '__main__':    S = "10001";    N = len(S);     # Function Call    print(minimumReverse(S, N)); # This code is contributed by shikhasingrajput

C#

 // C# program for the above approachusing System; public class GFG{   // Function to count the minimum number  // of substrings required to be reversed  // to make the string S alternating  static int minimumReverse(String s, int n)  {     // Store count of consecutive pairs    int k = 0 , l = 0 ;     // Stores the count of 1s and 0s    int sum1 = 0, sum0 = 0;     // Traverse through the string    for (int i = 1; i < n; i++)    {       if (s[i] == '1')         // Increment 1s count        sum1++;      else         // Increment 0s count        sum0++;       // Increment K if consecutive      // same elements are found      if (s[i] == s[i-1] && s[i] == '0')        k++;      else if( s[i] == s[i-1] && s[i] == '1')        l++;    }     // Increment 1s count    if(s == '1')          sum1++;    else  // Increment 0s count      sum0++;     // Check if it is possible or not    if (Math.Abs(sum1 - sum0) > 1)      return -1;     // Otherwise, print the number    // of required operations    return Math.Max(k , l);  }   // Driver code  public static void Main(String[] args)  {    String S = "10001";    int N = S.Length;     // Function Call    Console.Write(minimumReverse(S, N));  }}  // This code is contributed by shikhasingrajput

Javascript


Output:
2

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

My Personal Notes arrow_drop_up