# Maximize length of Subarray of 1’s after removal of a pair of consecutive Array elements

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:
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:
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++

 `// C++ program to implement` `// the above approach` `#include ` `using` `namespace` `std;`   `// Function to find the maximum` `// subarray length of ones` `int` `maxLen(``int` `A[], ``int` `N)` `{` `    ``// Stores the length, starting` `    ``// index and ending index of the` `    ``// subarrays` `    ``vector > v;`   `    ``for` `(``int` `i = 0; i < N; i++) {`   `        ``if` `(A[i] == 1) {`   `            ``// S : starting index` `            ``// of the sub-array` `            ``int` `s = i, len;`   `            ``// Traverse only continuous 1s` `            ``while` `(A[i] == 1 && i < N) {` `                ``i++;` `            ``}`   `            ``// Calculate length of the` `            ``// sub-array` `            ``len = i - s;`   `            ``// v[i][0] : Length of subarray` `            ``// v[i][1] : Starting Index of subarray` `            ``// v[i][2] : Ending Index of subarray` `            ``v.push_back({ len, s, i - 1 });` `        ``}` `    ``}`   `    ``// If no such sub-array exists` `    ``if` `(v.size() == 0) {` `        ``return` `-1;` `    ``}`   `    ``int` `ans = 0;`   `    ``// Traversing through the subarrays` `    ``for` `(``int` `i = 0; i < v.size() - 1; i++) {`   `        ``// Update maximum length` `        ``ans = max(ans, v[i][0]);`   `        ``// v[i+1][1] : Starting index of` `        ``// the next Sub-Array`   `        ``// v[i][2] : Ending Index of the` `        ``// current Sub-Array`   `        ``// v[i+1][1] - v[i][2] - 1 : Count of` `        ``// zeros between the two sub-arrays` `        ``if` `(v[i + 1][1] - v[i][2] - 1 == 2) {`   `            ``// Update length of both subarrays` `            ``// to the maximum` `            ``ans = max(ans, v[i][0] + v[i + 1][0]);` `        ``}` `        ``if` `(v[i + 1][1] - v[i][2] - 1 == 1) {`   `            ``// Update length of both subarrays - 1` `            ``// to the maximum` `            ``ans = max(ans, v[i][0] + v[i + 1][0] - 1);` `        ``}` `    ``}`   `    ``// Check if the last subarray has` `    ``// the maximum length` `    ``ans = max(v[v.size() - 1][0], ans);`   `    ``return` `ans;` `}`   `// Driver Code` `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

 `// Java program to implement` `// the above approach` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `    ``// Function to find the maximum` `    ``// subarray length of ones` `    ``static` `int` `maxLen(``int` `A[], ``int` `N)` `    ``{`   `        ``// Stores the length, starting` `        ``// index and ending index of the` `        ``// subarrays` `        ``List > v = ``new` `ArrayList<>();`   `        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``if` `(A[i] == ``1``) {`   `                ``// S : starting index` `                ``// of the sub-array` `                ``int` `s = i, len;`   `                ``// Traverse only continuous 1s` `                ``while` `(i < N && A[i] == ``1``) {` `                    ``i++;` `                ``}`   `                ``// Calculate length of the` `                ``// sub-array` `                ``len = i - s;`   `                ``// v[i][0] : Length of subarray` `                ``// v[i][1] : Starting Index of subarray` `                ``// v[i][2] : Ending Index of subarray` `                ``v.add(Arrays.asList(len, s, i - ``1``));` `            ``}` `        ``}`   `        ``// If no such sub-array exists` `        ``if` `(v.size() == ``0``) {` `            ``return` `-``1``;` `        ``}`   `        ``int` `ans = ``0``;`   `        ``// Traversing through the subarrays` `        ``for` `(``int` `i = ``0``; i < v.size() - ``1``; i++) {`   `            ``// Update maximum length` `            ``ans = Math.max(ans, v.get(i).get(``0``));`   `            ``// v[i+1][1] : Starting index of` `            ``// the next Sub-Array`   `            ``// v[i][2] : Ending Index of the` `            ``// current Sub-Array`   `            ``// v[i+1][1] - v[i][2] - 1 : Count of` `            ``// zeros between the two sub-arrays` `            ``if` `(v.get(i + ``1``).get(``1``) - v.get(i).get(``2``) - ``1` `                ``== ``2``) {`   `                ``// Update length of both subarrays` `                ``// to the maximum` `                ``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``) {`   `                ``// Update length of both subarrays - 1` `                ``// to the maximum` `                ``ans = Math.max(` `                    ``ans, v.get(i).get(``0``)` `                             ``+ v.get(i + ``1``).get(``0``) - ``1``);` `            ``}` `        ``}`   `        ``// Check if the last subarray has` `        ``// the maximum length` `        ``ans = Math.max(v.get(v.size() - ``1``).get(``0``), ans);`   `        ``return` `ans;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `arr[] = { ``1``, ``0``, ``1``, ``0``, ``0``, ``1` `};` `        ``int` `N = arr.length;`   `        ``System.out.println(maxLen(arr, N));` `    ``}` `}`   `// This code is contributed by offbeat`

## Python3

 `# Python3 program to implement` `# the above approach`   `# Function to find the maximum` `# subarray length of ones`     `def` `maxLen(A, N):`   `    ``# Stores the length, starting` `    ``# index and ending index of the` `    ``# subarrays` `    ``v ``=` `[]`   `    ``i ``=` `0` `    ``while` `i < N:` `        ``if` `(A[i] ``=``=` `1``):`   `            ``# S : starting index` `            ``# of the sub-array` `            ``s ``=` `i`   `            ``# Traverse only continuous 1s` `            ``while` `(i < N ``and` `A[i] ``=``=` `1``):` `                ``i ``+``=` `1`   `            ``# Calculate length of the` `            ``# sub-array` `            ``le ``=` `i ``-` `s`   `            ``# v[i][0] : Length of subarray` `            ``# v[i][1] : Starting Index of subarray` `            ``# v[i][2] : Ending Index of subarray` `            ``v.append([le, s, i ``-` `1``])`   `        ``i ``+``=` `1`   `    ``# If no such sub-array exists` `    ``if` `(``len``(v) ``=``=` `0``):` `        ``return` `-``1`   `    ``ans ``=` `0`   `    ``# Traversing through the subarrays` `    ``for` `i ``in` `range``(``len``(v) ``-` `1``):`   `        ``# Update maximum length` `        ``ans ``=` `max``(ans, v[i][``0``])`   `        ``# v[i+1][1] : Starting index of` `        ``# the next Sub-Array`   `        ``# v[i][2] : Ending Index of the` `        ``# current Sub-Array`   `        ``# v[i+1][1] - v[i][2] - 1 : Count of` `        ``# zeros between the two sub-arrays` `        ``if` `(v[i ``+` `1``][``1``] ``-` `v[i][``2``] ``-` `1` `=``=` `2``):`   `            ``# Update length of both subarrays` `            ``# to the maximum` `            ``ans ``=` `max``(ans, v[i][``0``] ``+` `v[i ``+` `1``][``0``])`   `        ``if` `(v[i ``+` `1``][``1``] ``-` `v[i][``2``] ``-` `1` `=``=` `1``):`   `            ``# Update length of both subarrays - 1` `            ``# to the maximum` `            ``ans ``=` `max``(ans, v[i][``0``] ``+` `v[i ``+` `1``][``0``] ``-` `1``)`   `    ``# Check if the last subarray has` `    ``# the maximum length` `    ``ans ``=` `max``(v[``len``(v) ``-` `1``][``0``], ans)`   `    ``return` `ans`     `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``arr ``=` `[``1``, ``0``, ``1``, ``0``, ``0``, ``1``]` `    ``N ``=` `len``(arr)`   `    ``print``(maxLen(arr, N))`   `# This code is contributed by chitranayal`

## C#

 `// C# program to implement` `// the above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG` `{`   `    ``// Function to find the maximum` `    ``// subarray length of ones` `    ``static` `int` `maxLen(``int` `[]A, ``int` `N)` `    ``{`   `        ``// Stores the length, starting` `        ``// index and ending index of the` `        ``// subarrays` `        ``List> v = ``new` `List>();`   `        ``for` `(``int` `i = 0; i < N; i++) ` `        ``{` `            ``if` `(A[i] == 1)` `            ``{`   `                ``// S : starting index` `                ``// of the sub-array` `                ``int` `s = i, len;`   `                ``// Traverse only continuous 1s` `                ``while` `(i < N && A[i] == 1) ` `                ``{` `                    ``i++;` `                ``}`   `                ``// Calculate length of the` `                ``// sub-array` `                ``len = i - s;`   `                ``// v[i,0] : Length of subarray` `                ``// v[i,1] : Starting Index of subarray` `                ``// v[i,2] : Ending Index of subarray` `                ``List<``int``> l = ``new` `List<``int``>{len, s, i - 1};` `                ``v.Add(l);` `            ``}` `        ``}`   `        ``// If no such sub-array exists` `        ``if` `(v.Count == 0) ` `        ``{` `            ``return` `-1;` `        ``}`   `        ``int` `ans = 0;`   `        ``// Traversing through the subarrays` `        ``for` `(``int` `i = 0; i < v.Count - 1; i++)` `        ``{`   `            ``// Update maximum length` `            ``ans = Math.Max(ans, v[i][0]);`   `            ``// v[i+1,1] : Starting index of` `            ``// the next Sub-Array`   `            ``// v[i,2] : Ending Index of the` `            ``// current Sub-Array`   `            ``// v[i+1,1] - v[i,2] - 1 : Count of` `            ``// zeros between the two sub-arrays` `            ``if` `(v[i + 1][1] - v[i][2] - 1` `                ``== 2) {`   `                ``// Update length of both subarrays` `                ``// to the maximum` `                ``ans = Math.Max(ans,` `                               ``v[i][0]` `                                   ``+ v[i + 1][0]);` `            ``}` `            ``if` `(v[i + 1][1] - v[i][2] - 1` `                ``== 1) ` `            ``{`   `                ``// Update length of both subarrays - 1` `                ``// to the maximum` `                ``ans = Math.Max(` `                    ``ans, v[i][0]` `                             ``+ v[i + 1][0] - 1);` `            ``}` `        ``}`   `        ``// Check if the last subarray has` `        ``// the maximum length` `        ``ans = Math.Max(v[v.Count - 1][0], ans);`   `        ``return` `ans;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(String []args)` `    ``{` `        ``int` `[]arr = { 1, 0, 1, 0, 0, 1 };` `        ``int` `N = arr.Length;`   `        ``Console.WriteLine(maxLen(arr, N));` `    ``}` `}`   `// This code is contributed by Princi Singh`

## Javascript

 ``

Output

`2`

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:

1. Create two arrays prefix and suffix of length n.
2. 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.
3. Run the loop from 2 to n-1:
• If arr[i-2]==1
• prefix[i]=prefix[i-1]+1
• else if arr[i-2]==0:
• prefix[i]=0
4. Run the loop from n-3 to 0:
• If arr[i+2]==1
• suffix[i]=suffix[i+1]+1
• else if arr[i-2]==0:
• suffix[i]=0
6. for i=0 to n-2: //Count the number of 1’s by skipping the current and the next element.

Implementation:

## C++

 `// C++ program to find the maximum count of 1s` `#include ` `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 then we increment the` `        ``// count of occurrences of 1's` `        ``if` `(arr[i - 2]` `            ``== 1) ` `            ``prefix[i] = prefix[i - 1] + 1;` `      `  `        ``// else we initialise the count with 0` `        ``else` `            ``prefix[i] = 0;` `    ``}` `    ``vector<``int``> suffix(n, 0);` `    ``for` `(``int` `i = n - 3; i >= 0; i--) ` `    ``{` `        ``// If arr[i+2]==1 then we increment the` `        ``// count of occurrences of 1's` `        ``if` `(arr[i + 2] == 1)` `            ``suffix[i] = suffix[i + 1] + 1;` `      `  `        ``// else we initialise the count with 0` `        ``else` `            ``suffix[i] = 0;` `    ``}` `    ``int` `ans = 0;` `    ``for` `(``int` `i = 0; i < n - 1; i++) ` `    ``{` `        ``// We get the maximum count by` `        ``// skipping the current and the` `        ``// next element.` `        ``ans = max(ans, prefix[i + 1] + suffix[i]);` `    ``}` `    ``cout << ans << ``"\n"``;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `n = 6;` `    ``vector<``int``> arr = { 1, 1, 1, 0, 1, 1 };` `    ``maxLengthOf1s(arr, n);` `    ``return` `0;` `}`

## Java

 `// Java program to find the maximum count of 1s` `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 then we increment` `        ``// the count of occurrences of 1's` `        ``if` `(arr[i - ``2``] == ``1``) ` `            ``prefix[i] = prefix[i - ``1``] + ``1``;` `       `  `        ``// Else we initialise the count with 0` `        ``else` `            ``prefix[i] = ``0``;` `    ``}` `    ``int` `suffix[] = ``new` `int``[n];` `    ``for``(``int` `i = n - ``3``; i >= ``0``; i--) ` `    ``{` `        `  `        ``// If arr[i+2]==1 then we increment` `        ``// the count of occurrences of 1's` `        ``if` `(arr[i + ``2``] == ``1``)` `            ``suffix[i] = suffix[i + ``1``] + ``1``;` `       `  `        ``// Else we initialise the count with 0` `        ``else` `            ``suffix[i] = ``0``;` `    ``}` `    ``int` `ans = ``0``;` `    ``for``(``int` `i = ``0``; i < n - ``1``; i++) ` `    ``{` `        `  `        ``// We get the maximum count by` `        ``// skipping the current and the` `        ``// next element.` `        ``ans = Math.max(ans, prefix[i + ``1``] + ` `                            ``suffix[i]);` `    ``}` `    ``System.out.println(ans);` `}`   `// Driver code` `public` `static` `void` `main(String[] args) ` `{` `    ``int` `n = ``6``;` `    ``int` `arr[] = { ``1``, ``1``, ``1``, ``0``, ``1``, ``1` `};` `    `  `    ``maxLengthOf1s(arr, n);` `}` `}`   `// This code is contributed by divyeshrabadiya07`

## Python3

 `# Python program to find the maximum count of 1s` `def` `maxLengthOf1s(arr, n):` `    ``prefix ``=` `[``0` `for` `i ``in` `range``(n)]` `    ``for` `i ``in` `range``(``2``, n):`   `        ``# If arr[i-2]==1 then we increment` `        ``# the count of occurrences of 1's` `        ``if``(arr[i ``-` `2``] ``=``=` `1``):` `            ``prefix[i] ``=` `prefix[i ``-` `1``] ``+` `1` `        `  `        ``# Else we initialise the count with 0` `        ``else``:` `            ``prefix[i] ``=` `0` `    ``suffix ``=` `[``0` `for` `i ``in` `range``(n)]` `    ``for` `i ``in` `range``(n ``-` `3``, ``-``1``, ``-``1``):` `        `  `        ``# If arr[i+2]==1 then we increment` `        ``# the count of occurrences of 1's` `        ``if``(arr[i ``+` `2``] ``=``=` `1``):` `            ``suffix[i] ``=` `suffix[i ``+` `1``] ``+` `1` `            `  `        ``# Else we initialise the count with 0` `        ``else``:` `            ``suffix[i] ``=` `0` `    ``ans ``=` `0` `    ``for` `i ``in` `range``(n ``-` `1``):` `      `  `        ``# We get the maximum count by` `        ``# skipping the current and the` `        ``# next element.` `        ``ans ``=` `max``(ans, prefix[i ``+` `1``] ``+` `suffix[i])` `    ``print``(ans)`   `# Driver code` `n ``=` `6` `arr ``=` `[``1``, ``1``, ``1``, ``0``, ``1``, ``1``]` `maxLengthOf1s(arr, n)`   `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# program to find the maximum count of 1s` `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 then we increment` `        ``// the count of occurrences of 1's` `        ``if` `(arr[i - 2] == 1) ` `            ``prefix[i] = prefix[i - 1] + 1;` `        `  `        ``// Else we initialise the count with 0` `        ``else` `            ``prefix[i] = 0;` `    ``}` `    ``int``[] suffix = ``new` `int``[n];` `    ``for``(``int` `i = n - 3; i >= 0; i--) ` `    ``{` `        `  `        ``// If arr[i+2]==1 then we increment` `        ``// the count of occurrences of 1's` `        ``if` `(arr[i + 2] == 1)` `            ``suffix[i] = suffix[i + 1] + 1;` `        `  `        ``// Else we initialise the count with 0` `        ``else` `            ``suffix[i] = 0;` `    ``}` `    ``int` `ans = 0;` `    ``for``(``int` `i = 0; i < n - 1; i++) ` `    ``{` `        `  `        ``// We get the maximum count by` `        ``// skipping the current and the` `        ``// next element.` `        ``ans = Math.Max(ans, prefix[i + 1] + suffix[i]);` `    ``}` `    ``Console.WriteLine(ans);` `}`   `// Driver code` `static` `void` `Main() ` `{` `    ``int` `n = 6;` `    ``int``[] arr = { 1, 1, 1, 0, 1, 1 };` `     `  `    ``maxLengthOf1s(arr, n);` `}` `}`   `// This code is contributed by divyesh072019`

## Javascript

 ``

Output

`4`

Time Complexity :O(n)
Auxiliary Space :O(n)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!