Maximum contiguous 1 possible in a binary string after k rotations

Given a binary string, you can rotate any substring of this string. For Example, let string be denoted by s. Let the first element of string be represented by s[0], second element be represented by s[1] and so on.
s = “100110111”

Suppose, we rotate the substring starting from s[2] and ending at s[4]. Then the string after this operation will be:
Resultant String = “101100111”

Now, you are allowed to do at most k operations to rotate any substring. You have to tell the maximum number of contiguous 1 you can make in this string in k or less than k rotations of substring.

Examples:

Input : 100011001
k = 1
Output : 3
Explanation:
k is 1, hence you can rotate only once. Rotate the substring starting from s[1] and ending at s[5]. The resultant string will be : 111000001. Hence, maximum contiguous 1 are 3.

Input : 001100111000110011100
k = 2
Output : 8
Explanation:
k is 2, hence you can rotate twice. Rotate the substring starting at s[6] and ending at s[15]. Resultant string after first rotation : 001100001100011111100. Then, rotate the substring starting at s[8] and ending at s[12]. Resultant string after second rotation : 001100000001111111100. Hence, maximum number of contiguous 1 are 8.



Concept For Solving:
In order to solve this problem, we will maintain the frequency of 1’s in portion of contiguous 1’s in the original string in a multiset. Then on each rotation, we will rotate that substring such that, 2 portions of contiguous 1(with maximum frequency) in the string come together. We will do this, by sorting the multiset from greatest to smallest element. We will take out top 2 elements of multiset and insert their sum back into the multiset. We will continue to do this until k rotations are completed or number of elements in multiset is reduced to 1.

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to calculate maximum contiguous
// ones in string
#include <bits/stdc++.h>
using namespace std;
  
// function to calculate maximum contiguous ones
int maxContiguousOnes(string s, int k)
{
  
    int i, j, a, b, count;
  
    // multiset is used to store frequency  of 
    // 1's of each portion of contiguous 1 in 
    // string in decreasing order
    multiset<int, greater<int> > m;
  
    // this loop calculate all the frequency
    // and stores them in multiset
    for (i = 0; i < s.length(); i++) {
        if (s[i] == '1') {
            count = 0;
            j = i;
            while (s[j] == '1' && j < s.length()) {
                count++;
                j++;
            }
            m.insert(count);
            i = j - 1;
        }
    }
  
    // if their is no 1 in string, then return 0
    if (m.size() == 0)
        return 0;
  
    // calculates maximum contiguous 1's on
    // doing rotations
    while (k > 0 && m.size() != 1) {
  
        // Delete largest two elements
        a = *(m.begin()); 
        m.erase(m.begin()); 
        b = *(m.begin()); 
        m.erase(m.begin()); 
  
        // insert their sum back into the multiset
        m.insert(a + b); 
        k--;
    }
  
    // return maximum contiguous ones 
    // possible after k rotations
    return *(m.begin());
}
  
// Driver code
int main()
{
    string s = "10011110011";
    int k = 1;
    cout << maxContiguousOnes(s, k);
    return 0;
}

chevron_right






                        filter_none









Output:


6






          
          
          
          

            

    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:
Shashank_Sharma
Check out this Author's contributed articles.
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 Improve this article if you find anything incorrect by clicking on  the "Improve Article" button below.