# 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.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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.

 `// C++ program to calculate maximum contiguous ` `// ones in string ` `#include ` `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; ` `} `

Output:

```6
```

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.