# Maximize distance between any two consecutive 1’s after flipping M 0’s

• Difficulty Level : Medium
• Last Updated : 21 Sep, 2022

Given the size of a binary array consisting of 0’s only as n and an integer m which is the number of flips allowed from 0’s o 1’s; the task is to maximize the distance between any two consecutive 1’s after flipping m 0’s to 1’s.

Examples:

Input: n = 5, m = 3
Output: 2
Explanation:
The initial array is arr = {0, 0, 0, 0, 0},
The final array is arr = {1, 0, 1, 0, 1},
So distance between two consecutive 1’s is 2.

Input: n = 9, m = 3
Output:
Explanation:
The initial array is arr = {0, 0, 0, 0, 0, 0, 0, 0, 0},
The final array is arr = {1, 0, 0, 0, 1, 0, 0, 0, 1},
so distance between two consecutive 1’s 4.

Approach:

• We can simply binary search on the distance between any two consecutive ones and check whether we can flip m numbers of zero’s to one’s.
• First, we set low = 1, and high = n – 1,
• Then check whether mid = (low+high)/2 will be a suitable distance or not.
• If it is then the updated answer is mid, else decrease high = mid – 1.

Below is the implementation of the above approach:

## CPP

 `// C++ program to Maximize distance between``// any two consecutive 1's after flipping M 0's` `#include ``using` `namespace` `std;` `// Function to return the count``bool` `check(``int` `arr[], ``int` `n, ``int` `m, ``int` `d)``{``    ``// Flipping zeros at distance "d"``    ``int` `i = 0;``    ``while` `(i < n && m > 0) {``        ``m--;``        ``i += d;``    ``}` `    ``return` `m == 0 ? ``true` `: ``false``;``}` `// Function to implement``// binary search``int` `maximumDistance(``int` `arr[], ``int` `n, ``int` `m)``{` `    ``int` `low = 1, high = n - 1;``    ``int` `ans = 0;` `    ``while` `(low <= high) {` `        ``int` `mid = (low + high) / 2;` `        ``// Check for valid distance i.e mid``        ``bool` `flag = check(arr, n, m, mid);` `        ``if` `(flag) {``            ``ans = mid;``            ``low = mid + 1;``        ``}``        ``else` `{``            ``high = mid - 1;``        ``}``    ``}` `    ``return` `ans;``}` `// Driver code``int` `main()``{` `    ``int` `n = 5, m = 3;``    ``int` `arr[n] = { 0 };` `    ``cout << maximumDistance(arr, n, m);` `    ``return` `0;``}`

## Java

 `// Java program to Maximize distance between``// any two consecutive 1's after flipping M 0's` `class` `GFG``{` `    ``// Function to return the count``    ``static` `boolean` `check(``int` `arr[], ``int` `n, ``int` `m, ``int` `d)``    ``{``        ` `        ``// Flipping zeros at distance "d"``        ``int` `i = ``0``;``        ``while` `(i < n && m > ``0``)``        ``{``            ``m--;``            ``i += d;``        ``}` `        ``return` `m == ``0` `? ``true` `: ``false``;``    ``}` `    ``// Function to implement``    ``// binary search``    ``static` `int` `maximumDistance(``int` `arr[], ``int` `n, ``int` `m)``    ``{` `        ``int` `low = ``1``, high = n - ``1``;``        ``int` `ans = ``0``;` `        ``while` `(low <= high)``        ``{` `            ``int` `mid = (low + high) / ``2``;` `            ``// Check for valid distance i.e mid``            ``boolean` `flag = check(arr, n, m, mid);` `            ``if` `(flag)``            ``{``                ``ans = mid;``                ``low = mid + ``1``;``            ``}``            ``else``            ``{``                ``high = mid - ``1``;``            ``}``        ``}` `        ``return` `ans;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``int` `n = ``5``, m = ``3``;``        ``int` `arr[] = ``new` `int``[n];` `        ``System.out.print(maximumDistance(arr, n, m));` `    ``}``}` `// This code is contributed by 29AjayKumar`

## Python

 `# Python3 program to Maximize distance between``# any two consecutive 1's after flipping M 0's` `# Function to return the count``def` `check(arr, n, m, d):``    ` `    ``# Flipping zeros at distance "d"``    ``i ``=` `0``    ``while` `(i < n ``and` `m > ``0``):``        ``m ``-``=` `1``        ``i ``+``=` `d``    ``if` `m ``=``=` `0``:``        ``return` `True` `    ``return` `False` `# Function to implement``# binary search``def` `maximumDistance(arr, n, m):` `    ``low ``=` `1``    ``high ``=` `n ``-` `1``    ``ans ``=` `0` `    ``while` `(low <``=` `high):` `        ``mid ``=` `(low ``+` `high) ``/``/` `2` `        ``# Check for valid distance i.e mid``        ``flag ``=` `check(arr, n, m, mid)` `        ``if` `(flag) :``            ``ans ``=` `mid``            ``low ``=` `mid ``+` `1``        ``else` `:``            ``high ``=` `mid ``-` `1`  `    ``return` `ans` `# Driver code` `n ``=` `5``m ``=` `3``arr ``=` `[``0``] ``*` `n` `print``(maximumDistance(arr, n, m))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program to Maximize distance between``// any two consecutive 1's after flipping M 0's``using` `System;` `class` `GFG``{` `    ``// Function to return the count``    ``static` `bool` `check(``int` `[]arr, ``int` `n, ``int` `m, ``int` `d)``    ``{``        ` `        ``// Flipping zeros at distance "d"``        ``int` `i = 0;``        ``while` `(i < n && m > 0)``        ``{``            ``m--;``            ``i += d;``        ``}` `        ``return` `m == 0 ? ``true` `: ``false``;``    ``}` `    ``// Function to implement``    ``// binary search``    ``static` `int` `maximumDistance(``int` `[]arr, ``int` `n, ``int` `m)``    ``{` `        ``int` `low = 1, high = n - 1;``        ``int` `ans = 0;` `        ``while` `(low <= high)``        ``{` `            ``int` `mid = (low + high) / 2;` `            ``// Check for valid distance i.e mid``            ``bool` `flag = check(arr, n, m, mid);` `            ``if` `(flag)``            ``{``                ``ans = mid;``                ``low = mid + 1;``            ``}``            ``else``            ``{``                ``high = mid - 1;``            ``}``        ``}` `        ``return` `ans;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{` `        ``int` `n = 5, m = 3;``        ``int` `[]arr = ``new` `int``[n];` `        ``Console.Write(maximumDistance(arr, n, m));` `    ``}``}` `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output:

`2`

Time Complexity: O(n*log(n))
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up