# Minimum time required to cover a Binary Array

• Last Updated : 17 Nov, 2021

Given an integer N which represents the size of a boolean array that is initially filled with 0, and also given an array arr[] of size K consisting of (1-based) indices at which ‘1’ are present in the boolean array. Now, at one unit of time the adjacent cells of the arr[i] in the boolean array become 1 that is 010 becomes 111. Find the minimum time required to convert the whole array into 1s.
Examples:

Input : N = 5, arr[] = {1, 4}
Output :
Explanation:
Initially the boolean array is of size 5 filled with 5 zeros. arr[] represents places at which 1 is present in the boolean array. Therefore, the boolean array becomes 10010.
Now, at time (t) = 1, the 0s at 3rd and 5th position becomes 1 => 10111 and at the same time, 0 at 2nd position becomes 1 => 11111. All the 1s initially increment their adjacent 0s at the same moment of time. So at t=1, the string gets converted to all 1s.
Input : N=7, arr[] = {1, 7}
Output :
Explanation:
At time (t) = 1, 1000001 becomes 1100011
At time (t) = 2, 1100011 becomes 1110111
At time (t) = 3, 1110111 becomes 1111111
Hence, minimum time is 3 to change the binary array into 1.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Approach:
To solve the problem mentioned above we have to observe that we need to find the longest segment of zeroes until 1 appears. For example, for a binary number 00010000010000, the longest segment of 0s is from 4th to 10th position. Now, observe that there are 5 0s between the indices which is an odd number. Hence, we can conclude that to cover 5 zeros we need 5/2 + 1 that is 3 units of time because all the other segments will get filled in less than or equal to 3 units of time.

• If the longest zero segments are odd then we can conclude that x/2 + 1 unit of time is required where x is the number of 0s in the longest segment.
• If the longest zero segments are even then we can conclude that x/2 units of time are required where x is the number of 0s in the longest segment.

We can calculate the maximum length contiguous segment until 1 occurs in the boolean array and return the answer depends upon whether the length is odd or even.
Below is the implementation of the above approach:

## C++

 `// CPP implementation to find the``// Minimum time required to cover a Binary Array``#include ``using` `namespace` `std;` `// function to calculate the time``int` `solve(vector<``int``> arr, ``int` `n)``{` `    ``int` `k = arr.size();` `    ``// Map to mark or store the binary values``    ``bool` `mp[n + 2];` `    ``// Firstly fill the boolean``    ``// array with all zeroes``    ``for` `(``int` `i = 0; i <= n; i++) {``        ``mp[i] = 0;``    ``}` `    ``// Mark the 1s``    ``for` `(``int` `i = 0; i < k; i++) {``        ``mp[arr[i]] = 1;``    ``}` `    ``// Number of 0s until first '1' occurs``    ``int` `leftSegment = arr - 1;` `    ``// Maximum Number of 0s in between 2 '1's.``    ``for` `(``int` `i = 1; i < k; i++) {``        ``leftSegment = max(leftSegment, arr[i] - arr[i - 1] - 1);``    ``}` `    ``// Number of 0s from right until first '1' occurs``    ``int` `rightSegment = n - arr[k - 1];` `    ``// Return maximum from left and right segment``    ``int` `maxSegment = max(leftSegment, rightSegment);` `    ``int` `tim;` `    ``// check if count is odd``    ``if` `(maxSegment & 1)``        ``tim = (maxSegment / 2) + 1;` `    ``// check ifcount is even``    ``else``        ``tim = maxSegment / 2;` `    ``// return the time``    ``return` `tim;``}` `// driver code``int` `main()``{``    ``// initialise N``    ``int` `N = 5;` `    ``// array initialisation``    ``vector<``int``> arr = { 1, 4 };` `    ``cout << solve(arr, N);``}`

## Java

 `// Java implementation to find the``// Minimum time required to cover a Binary Array``class` `GFG {` `    ``// function to calculate the time``    ``static` `int` `solve(``int` `[]arr, ``int` `n)``    ``{``    ` `        ``int` `k = arr.length;``    ` `        ``// Map to mark or store the binary values``        ``int` `mp[] = ``new` `int``[n + ``2``];``    ` `        ``// Firstly fill the boolean``        ``// array with all zeroes``        ``for` `(``int` `i = ``0``; i <= n; i++) {``            ``mp[i] = ``0``;``        ``}``    ` `        ``// Mark the 1s``        ``for` `(``int` `i = ``0``; i < k; i++) {``            ``mp[arr[i]] = ``1``;``        ``}``    ` `        ``// Number of 0s until first '1' occurs``        ``int` `leftSegment = arr[``0``] - ``1``;``    ` `        ``// Maximum Number of 0s in between 2 '1's.``        ``for` `(``int` `i = ``1``; i < k; i++) {``            ``leftSegment = Math.max(leftSegment, arr[i] - arr[i - ``1``] - ``1``);``        ``}``    ` `        ``// Number of 0s from right until first '1' occurs``        ``int` `rightSegment = n - arr[k - ``1``];``    ` `        ``// Return maximum from left and right segment``        ``int` `maxSegment = Math.max(leftSegment, rightSegment);``    ` `        ``int` `tim;``    ` `        ``// check if count is odd``        ``if` `((maxSegment & ``1``) == ``1``)``            ``tim = (maxSegment / ``2``) + ``1``;``    ` `        ``// check ifcount is even``        ``else``            ``tim = maxSegment / ``2``;``    ` `        ``// return the time``        ``return` `tim;``    ``}``    ` `    ``// driver code``    ``public` `static` `void` `main (String[] args)``    ``{``        ``// initialise N``        ``int` `N = ``5``;``    ` `        ``// array initialisation``        ``int` `arr[] = { ``1``, ``4` `};``    ` `        ``System.out.println(solve(arr, N));``    ``}``}` `// This code is contributed by AnkitRai01`

## Python3

 `# Python3 implementation to find the``# Minimum time required to cover a Binary Array` `# function to calculate the time``def` `solve(arr, n) :` `    ``k ``=` `len``(arr)` `    ``# Map to mark or store the binary values``    ``# Firstly fill the boolean``    ``# array with all zeroes``    ``mp ``=` `[``False` `for` `i ``in` `range``(n ``+` `2``)]` `    ``# Mark the 1s``    ``for` `i ``in` `range``(k) :``        ``mp[arr[i]] ``=` `True` `    ``# Number of 0s until first '1' occurs``    ``leftSegment ``=` `arr[``0``] ``-` `1` `    ``# Maximum Number of 0s in between 2 '1's.``    ``for` `i ``in` `range``(``1``,k) :``        ``leftSegment ``=` `max``(leftSegment, arr[i] ``-` `arr[i ``-` `1``] ``-` `1``)` `    ``# Number of 0s from right until first '1' occurs``    ``rightSegment ``=` `n ``-` `arr[k ``-` `1``]` `    ``# Return maximum from left and right segment``    ``maxSegment ``=` `max``(leftSegment, rightSegment);` `    ``tim ``=` `0` `    ``# check if count is odd``    ``if` `(maxSegment & ``1``) :``        ``tim ``=` `(maxSegment ``/``/` `2``) ``+` `1` `    ``# check ifcount is even``    ``else` `:``        ``tim ``=` `maxSegment ``/``/` `2` `    ``# return the time``    ``return` `tim` `# Driver code``# initialise N``N ``=` `5` `# array initialisation``arr ``=` `[ ``1``, ``4` `]` `print``(solve(arr, N))` `# This code is contributed by Sanjit_Prasad`

## C#

 `// C# implementation to find the``// Minimum time required to cover``// a Binary Array``using` `System;` `class` `GFG{` `// Function to calculate the time``static` `int` `solve(``int``[] arr, ``int` `n)``{``    ``int` `k = arr.Length;` `    ``// Map to mark or store the binary values``    ``int``[] mp = ``new` `int``[n + 2];` `    ``// Firstly fill the boolean``    ``// array with all zeroes``    ``for``(``int` `i = 0; i <= n; i++)``    ``{``        ``mp[i] = 0;``    ``}` `    ``// Mark the 1s``    ``for``(``int` `i = 0; i < k; i++)``    ``{``        ``mp[arr[i]] = 1;``    ``}` `    ``// Number of 0s until first '1' occurs``    ``int` `leftSegment = arr - 1;` `    ``// Maximum Number of 0s in between 2 '1's.``    ``for``(``int` `i = 1; i < k; i++)``    ``{``        ``leftSegment = Math.Max(leftSegment,``                               ``arr[i] -``                               ``arr[i - 1] - 1);``    ``}` `    ``// Number of 0s from right until first '1' occurs``    ``int` `rightSegment = n - arr[k - 1];` `    ``// Return maximum from left and right segment``    ``int` `maxSegment = Math.Max(leftSegment,``                              ``rightSegment);` `    ``int` `tim;` `    ``// Check if count is odd``    ``if` `((maxSegment & 1) == 1)``        ``tim = (maxSegment / 2) + 1;` `    ``// Check ifcount is even``    ``else``        ``tim = maxSegment / 2;` `    ``// Return the time``    ``return` `tim;``}` `// Driver code``public` `static` `void` `Main ()``{``    ` `    ``// Initialise N``    ``int` `N = 5;` `    ``// Array initialisation``    ``int``[] arr = { 1, 4 };` `    ``Console.Write(solve(arr, N));``}``}` `// This code is contributed by chitranayal`

## Javascript

 ``
Output:
`1`

Time Complexity: O(N)

Auxiliary Space: O(N)

My Personal Notes arrow_drop_up