Given a binary array arr[] consisting of N elements, the task is to find the maximum possible length of a subarray of only 1’s, after deleting a single pair of consecutive array elements. If no such subarray exists, print -1.
Examples:
Input: arr[] = {1, 1, 1, 0, 0, 1}
Output: 4
Explanation:
Removal of the pair {0, 0} modifies the array to {1, 1, 1, 1}, thus maximizing the length of the longest possible subarray consisting only of 1’s.
Input: arr[] = {1, 1, 1, 0, 0, 0, 1}
Output: 3
Explanation:
Removal of any consecutive pair from the subarray {0, 0, 0, 1} maintains the longest possible subarray of 1’s, i.e. {1, 1, 1}.
Naive Approach:
The simplest approach to solve the problem is to generate all possible pairs of consecutive elements from the array and for each pair, calculate the maximum possible length of a subarray of 1‘s. Finally, print the maximum possible length of such a subarray obtained.
Time Complexity: O(N2)
Auxiliary Space: O(1)
Efficient Approach:
Follow the steps given below to solve the problem:
- Initialize an auxiliary 2D vector V.
- Keep track of all the contiguous subarrays consisting of only 1’s.
- Store the length, starting index, and ending index of the subarrays.
- Now, calculate the number of 0’s between any two subarrays of 1‘s.
- Based on the count of 0’s obtained, update the maximum length of subarrays possible:
- If exactly two 0‘s are present between two subarrays, update the maximum possible length by comparing the combined length of both subarrays.
- If exactly one 0 is present between two subarrays, update the maximum possible length by comparing the combined length of both subarrays – 1.
- Finally, print the maximum possible length obtained
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int maxLen(int A[], int N)
{
vector<vector<int> > v;
for (int i = 0; i < N; i++) {
if (A[i] == 1) {
int s = i, len;
while (A[i] == 1 && i < N) {
i++;
}
len = i - s;
v.push_back({ len, s, i - 1 });
}
}
if (v.size() == 0) {
return -1;
}
int ans = 0;
for (int i = 0; i < v.size() - 1; i++) {
ans = max(ans, v[i][0]);
if (v[i + 1][1] - v[i][2] - 1 == 2) {
ans = max(ans, v[i][0] + v[i + 1][0]);
}
if (v[i + 1][1] - v[i][2] - 1 == 1) {
ans = max(ans, v[i][0] + v[i + 1][0] - 1);
}
}
ans = max(v[v.size() - 1][0], ans);
return ans;
}
int main()
{
int arr[] = { 1, 0, 1, 0, 0, 1 };
int N = sizeof(arr) / sizeof(arr[0]);
cout << maxLen(arr, N) << endl;
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG {
static int maxLen(int A[], int N)
{
List<List<Integer> > v = new ArrayList<>();
for (int i = 0; i < N; i++) {
if (A[i] == 1) {
int s = i, len;
while (i < N && A[i] == 1) {
i++;
}
len = i - s;
v.add(Arrays.asList(len, s, i - 1));
}
}
if (v.size() == 0) {
return -1;
}
int ans = 0;
for (int i = 0; i < v.size() - 1; i++) {
ans = Math.max(ans, v.get(i).get(0));
if (v.get(i + 1).get(1) - v.get(i).get(2) - 1
== 2) {
ans = Math.max(ans,
v.get(i).get(0)
+ v.get(i + 1).get(0));
}
if (v.get(i + 1).get(1) - v.get(i).get(2) - 1
== 1) {
ans = Math.max(
ans, v.get(i).get(0)
+ v.get(i + 1).get(0) - 1);
}
}
ans = Math.max(v.get(v.size() - 1).get(0), ans);
return ans;
}
public static void main(String args[])
{
int arr[] = { 1, 0, 1, 0, 0, 1 };
int N = arr.length;
System.out.println(maxLen(arr, N));
}
}
|
Python3
def maxLen(A, N):
v = []
i = 0
while i < N:
if (A[i] == 1):
s = i
while (i < N and A[i] == 1):
i += 1
le = i - s
v.append([le, s, i - 1])
i += 1
if (len(v) == 0):
return -1
ans = 0
for i in range(len(v) - 1):
ans = max(ans, v[i][0])
if (v[i + 1][1] - v[i][2] - 1 == 2):
ans = max(ans, v[i][0] + v[i + 1][0])
if (v[i + 1][1] - v[i][2] - 1 == 1):
ans = max(ans, v[i][0] + v[i + 1][0] - 1)
ans = max(v[len(v) - 1][0], ans)
return ans
if __name__ == "__main__":
arr = [1, 0, 1, 0, 0, 1]
N = len(arr)
print(maxLen(arr, N))
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static int maxLen(int []A, int N)
{
List<List<int>> v = new List<List<int>>();
for (int i = 0; i < N; i++)
{
if (A[i] == 1)
{
int s = i, len;
while (i < N && A[i] == 1)
{
i++;
}
len = i - s;
List<int> l = new List<int>{len, s, i - 1};
v.Add(l);
}
}
if (v.Count == 0)
{
return -1;
}
int ans = 0;
for (int i = 0; i < v.Count - 1; i++)
{
ans = Math.Max(ans, v[i][0]);
if (v[i + 1][1] - v[i][2] - 1
== 2) {
ans = Math.Max(ans,
v[i][0]
+ v[i + 1][0]);
}
if (v[i + 1][1] - v[i][2] - 1
== 1)
{
ans = Math.Max(
ans, v[i][0]
+ v[i + 1][0] - 1);
}
}
ans = Math.Max(v[v.Count - 1][0], ans);
return ans;
}
public static void Main(String []args)
{
int []arr = { 1, 0, 1, 0, 0, 1 };
int N = arr.Length;
Console.WriteLine(maxLen(arr, N));
}
}
|
Javascript
<script>
function maxLen(A, N)
{
var v = [];
for (var i = 0; i < N; i++) {
if (A[i] == 1) {
var s = i, len;
while (A[i] == 1 && i < N) {
i++;
}
len = i - s;
v.push([len, s, i - 1]);
}
}
if (v.length == 0) {
return -1;
}
var ans = 0;
for (var i = 0; i < v.length - 1; i++) {
ans = Math.max(ans, v[i][0]);
if (v[i + 1][1] - v[i][2] - 1 == 2) {
ans = Math.max(ans, v[i][0] + v[i + 1][0]);
}
if (v[i + 1][1] - v[i][2] - 1 == 1) {
ans = Math.max(ans, v[i][0] + v[i + 1][0] - 1);
}
}
ans = Math.max(v[v.length - 1][0], ans);
return ans;
}
var arr = [1, 0, 1, 0, 0, 1];
var N = arr.length;
document.write( maxLen(arr, N));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N)
Method 2:
Prefix and Suffix Arrays
Count the number of 1’s between the occurrences of 0’s. If we find a 0 then we need to find the maximum length of 1’s if we skip those 2 consecutive elements. We can use the concepts of Prefix and Suffix arrays to solve the problem.
Find the length of consecutive 1s from the start of the array and store the count in the prefix array. Find the length of consecutive 1s from the ending of the array and store the count in the ending array.
We traverse both the arrays and find the maximum no. of 1s.
Algorithm:
- Create two arrays prefix and suffix of length n.
- Initialise prefix[0]=0,prefix[1]=0 and suffix[n-1]=0,suffix[n-2]=0. This tells us that there are no 1s before the first 2 elements and after the last 2 elements.
- Run the loop from 2 to n-1:
- If arr[i-2]==1
- else if arr[i-2]==0:
- Run the loop from n-3 to 0:
- If arr[i+2]==1
- else if arr[i-2]==0:
- Initialize answer=INT_MIN
- for i=0 to n-2: //Count the number of 1’s by skipping the current and the next element.
- answer=max(answer,prefix[i+1]+suffix[i]
- print answer
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
void maxLengthOf1s(vector<int> arr, int n)
{
vector<int> prefix(n, 0);
for (int i = 2; i < n; i++)
{
if (arr[i - 2]
== 1)
prefix[i] = prefix[i - 1] + 1;
else
prefix[i] = 0;
}
vector<int> suffix(n, 0);
for (int i = n - 3; i >= 0; i--)
{
if (arr[i + 2] == 1)
suffix[i] = suffix[i + 1] + 1;
else
suffix[i] = 0;
}
int ans = 0;
for (int i = 0; i < n - 1; i++)
{
ans = max(ans, prefix[i + 1] + suffix[i]);
}
cout << ans << "\n";
}
int main()
{
int n = 6;
vector<int> arr = { 1, 1, 1, 0, 1, 1 };
maxLengthOf1s(arr, n);
return 0;
}
|
Java
class GFG{
public static void maxLengthOf1s(int arr[], int n)
{
int prefix[] = new int[n];
for(int i = 2; i < n; i++)
{
if (arr[i - 2] == 1)
prefix[i] = prefix[i - 1] + 1;
else
prefix[i] = 0;
}
int suffix[] = new int[n];
for(int i = n - 3; i >= 0; i--)
{
if (arr[i + 2] == 1)
suffix[i] = suffix[i + 1] + 1;
else
suffix[i] = 0;
}
int ans = 0;
for(int i = 0; i < n - 1; i++)
{
ans = Math.max(ans, prefix[i + 1] +
suffix[i]);
}
System.out.println(ans);
}
public static void main(String[] args)
{
int n = 6;
int arr[] = { 1, 1, 1, 0, 1, 1 };
maxLengthOf1s(arr, n);
}
}
|
Python3
def maxLengthOf1s(arr, n):
prefix = [0 for i in range(n)]
for i in range(2, n):
if(arr[i - 2] == 1):
prefix[i] = prefix[i - 1] + 1
else:
prefix[i] = 0
suffix = [0 for i in range(n)]
for i in range(n - 3, -1, -1):
if(arr[i + 2] == 1):
suffix[i] = suffix[i + 1] + 1
else:
suffix[i] = 0
ans = 0
for i in range(n - 1):
ans = max(ans, prefix[i + 1] + suffix[i])
print(ans)
n = 6
arr = [1, 1, 1, 0, 1, 1]
maxLengthOf1s(arr, n)
|
C#
using System;
class GFG{
static void maxLengthOf1s(int[] arr, int n)
{
int[] prefix = new int[n];
for(int i = 2; i < n; i++)
{
if (arr[i - 2] == 1)
prefix[i] = prefix[i - 1] + 1;
else
prefix[i] = 0;
}
int[] suffix = new int[n];
for(int i = n - 3; i >= 0; i--)
{
if (arr[i + 2] == 1)
suffix[i] = suffix[i + 1] + 1;
else
suffix[i] = 0;
}
int ans = 0;
for(int i = 0; i < n - 1; i++)
{
ans = Math.Max(ans, prefix[i + 1] + suffix[i]);
}
Console.WriteLine(ans);
}
static void Main()
{
int n = 6;
int[] arr = { 1, 1, 1, 0, 1, 1 };
maxLengthOf1s(arr, n);
}
}
|
Javascript
<script>
function maxLengthOf1s(arr, n)
{
let prefix = new Array(n);
prefix.fill(0);
for(let i = 2; i < n; i++)
{
if (arr[i - 2] == 1)
prefix[i] = prefix[i - 1] + 1;
else
prefix[i] = 0;
}
let suffix = new Array(n);
suffix.fill(0);
for(let i = n - 3; i >= 0; i--)
{
if (arr[i + 2] == 1)
suffix[i] = suffix[i + 1] + 1;
else
suffix[i] = 0;
}
let ans = 0;
for(let i = 0; i < n - 1; i++)
{
ans = Math.max(ans, prefix[i + 1] + suffix[i]);
}
document.write(ans);
}
let n = 6;
let arr = [ 1, 1, 1, 0, 1, 1 ];
maxLengthOf1s(arr, n);
</script>
|
Time Complexity :O(n)
Auxiliary Space :O(n)