Maximum length sub-array which satisfies the given conditions
Last Updated :
07 Dec, 2022
Given a binary array arr[], the task is to find the length of the longest sub-array of the given array such that if the sub-array is divided into two equal-sized sub-arrays then both the sub-arrays either contain all 0s or all 1s. For example, the two sub-arrays must be of the form {0, 0, 0, 0} and {1, 1, 1, 1} or {1, 1, 1} and {0, 0, 0} and not {0, 0, 0} and {0, 0, 0}
Examples:
Input: arr[] = {1, 1, 1, 0, 0, 1, 1}
Output: 4
{1, 1, 0, 0} and {0, 0, 1, 1} are the maximum length valid sub-arrays.
Input: arr[] = {1, 1, 0, 0, 0, 1, 1, 1, 1}
Output: 6
{0, 0, 0, 1, 1, 1} is the only valid sub-array with maximum length.
Approach: For every two consecutive elements of the array say arr[i] and arr[j] where j = i + 1, treat them as the middle two elements of the required sub-array. In order for this sub-array to be a valid sub-array arr[i] must not be equal to arr[j]. If it can be a valid sub-array then its size is 2. Now, try to extend this sub-array to a bigger size by decrementing i and incrementing j at the same time and all the elements before index i and after index j must be equal to arr[i] and arr[j] respectively. Print the size of the longest such sub-array found so far.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int maxLength( int arr[], int n)
{
int maxLen = 0;
int i = 0;
int j = i + 1;
while (j < n) {
if (arr[i] != arr[j]) {
maxLen = max(maxLen, 2);
int l = i - 1;
int r = j + 1;
while (l >= 0 && r < n && arr[l] == arr[i]
&& arr[r] == arr[j]) {
l--;
r++;
}
maxLen = max(maxLen, 2 * (r - j));
}
i++;
j = i + 1;
}
return maxLen;
}
int main()
{
int arr[] = { 1, 1, 1, 0, 0, 1, 1 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << maxLength(arr, n);
return 0;
}
|
Java
class GFG {
static int maxLength( int arr[], int n)
{
int maxLen = 0 ;
int i = 0 ;
int j = i + 1 ;
while (j < n) {
if (arr[i] != arr[j]) {
maxLen = Math.max(maxLen, 2 );
int l = i - 1 ;
int r = j + 1 ;
while (l >= 0 && r < n && arr[l] == arr[i] && arr[r] == arr[j]) {
l--;
r++;
}
maxLen = Math.max(maxLen, 2 * (r - j));
}
i++;
j = i + 1 ;
}
return maxLen;
}
public static void main(String[] args)
{
int arr[] = { 1 , 1 , 1 , 0 , 0 , 1 , 1 };
int n = arr.length;
System.out.println(maxLength(arr, n));
}
}
|
Python3
def maxLength(arr, n):
maxLen = 0
i = 0
j = i + 1
while (j < n):
if (arr[i] ! = arr[j]):
maxLen = max (maxLen, 2 )
l = i - 1
r = j + 1
while (l > = 0 and r < n and arr[l] = = arr[i]
and arr[r] = = arr[j]):
l - = 1
r + = 1
maxLen = max (maxLen, 2 * (r - j))
i + = 1
j = i + 1
return maxLen
arr = [ 1 , 1 , 1 , 0 , 0 , 1 , 1 ]
n = len (arr)
print (maxLength(arr, n))
|
C#
using System;
class GFG {
static int maxLength( int [] arr, int n)
{
int maxLen = 0;
int i = 0;
int j = i + 1;
while (j < n) {
if (arr[i] != arr[j]) {
maxLen = Math.Max(maxLen, 2);
int l = i - 1;
int r = j + 1;
while (l >= 0 && r < n && arr[l] == arr[i] && arr[r] == arr[j]) {
l--;
r++;
}
maxLen = Math.Max(maxLen, 2 * (r - j));
}
i++;
j = i + 1;
}
return maxLen;
}
public static void Main(String[] args)
{
int [] arr = { 1, 1, 1, 0, 0, 1, 1 };
int n = arr.Length;
Console.WriteLine(maxLength(arr, n));
}
}
|
Javascript
<script>
function maxLength(arr, n)
{
let maxLen = 0;
let i = 0;
let j = i + 1;
while (j < n) {
if (arr[i] != arr[j]) {
maxLen = Math.max(maxLen, 2);
let l = i - 1;
let r = j + 1;
while (l >= 0 && r < n && arr[l] == arr[i]
&& arr[r] == arr[j]) {
l--;
r++;
}
maxLen = Math.max(maxLen, 2 * (r - j));
}
i++;
j = i + 1;
}
return maxLen;
}
let arr = [ 1, 1, 1, 0, 0, 1, 1 ];
let n = arr.length;
document.write(maxLength(arr, n));
</script>
|
Time Complexity: O(n2), where n is the length of the given array.
Auxiliary Space: O(1)
Alternate approach: We can maintain the max length of previous similar elements and try to form subarray with the next different contiguous element and maximize the subarray length.
Below is the implementation of the above approach:
C++
#include <iostream>
using namespace std;
int maxLength( int a[], int n)
{
int maxLen = 0;
int prev_cnt = 0, curr_cnt = 1;
for ( int i = 1; i < n; i++) {
if (a[i] == a[i - 1])
curr_cnt++;
else {
prev_cnt = curr_cnt;
curr_cnt = 1;
}
maxLen = max(maxLen, min(prev_cnt, curr_cnt));
}
return (2 * maxLen);
}
int main()
{
int arr[] = { 1, 1, 1, 0, 0, 1, 1 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << maxLength(arr, n);
return 0;
}
|
Java
class GFG
{
static int maxLength( int a[], int n)
{
int maxLen = 0 ;
int prev_cnt = 0 , curr_cnt = 1 ;
for ( int i = 1 ; i < n; i++)
{
if (a[i] == a[i - 1 ])
curr_cnt++;
else
{
prev_cnt = curr_cnt;
curr_cnt = 1 ;
}
maxLen = Math.max(maxLen,
Math.min(prev_cnt, curr_cnt));
}
return ( 2 * maxLen);
}
public static void main(String[] args)
{
int arr[] = { 1 , 1 , 1 , 0 , 0 , 1 , 1 };
int n = arr.length;
System.out.println(maxLength(arr, n));
}
}
|
Python3
def maxLength(a, n):
maxLen = 0 ;
prev_cnt = 0 ; curr_cnt = 1 ;
for i in range ( 1 , n):
if (a[i] = = a[i - 1 ]):
curr_cnt + = 1 ;
else :
prev_cnt = curr_cnt;
curr_cnt = 1 ;
maxLen = max (maxLen, min (prev_cnt,
curr_cnt));
return ( 2 * maxLen);
arr = [ 1 , 1 , 1 , 0 , 0 , 1 , 1 ];
n = len (arr);
print (maxLength(arr, n));
|
C#
using System;
class GFG
{
static int maxLength( int [] a, int n)
{
int maxLen = 0;
int prev_cnt = 0, curr_cnt = 1;
for ( int i = 1; i < n; i++)
{
if (a[i] == a[i - 1])
curr_cnt++;
else
{
prev_cnt = curr_cnt;
curr_cnt = 1;
}
maxLen = Math.Max(maxLen,
Math.Min(prev_cnt, curr_cnt));
}
return (2 * maxLen);
}
public static void Main()
{
int [] arr = { 1, 1, 1, 0, 0, 1, 1 };
int n = arr.Length;
Console.WriteLine(maxLength(arr, n));
}
}
|
Javascript
<script>
function maxLength(a, n)
{
let maxLen = 0;
let prev_cnt = 0, curr_cnt = 1;
for (let i = 1; i < n; i++) {
if (a[i] == a[i - 1])
curr_cnt++;
else {
prev_cnt = curr_cnt;
curr_cnt = 1;
}
maxLen = Math.max(maxLen, Math.min(prev_cnt, curr_cnt));
}
return (2 * maxLen);
}
let arr = [ 1, 1, 1, 0, 0, 1, 1 ];
let n = arr.length;
document.write(maxLength(arr, n));
</script>
|
Time Complexity: O(n), where n is the length of the given array.
Auxiliary Space: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...