给定二进制数组arr [] ,任务是找到给定数组的最长子数组的长度,这样,如果将子数组分为两个相等大小的子数组,则两个子数组都包含全0或全1 。例如,两个子数组的格式必须为{0,0,0,0}和{1,1,1,1}或{1,1,1}和{0,0,0},而不能为{0,0,0}和{0,0,0}
例子:
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.
方法:对于数组的每两个连续元素,说arr [i]和arr [j] ,其中j = i + 1 ,将它们视为所需子数组的中间两个元素。为了使该子数组成为有效的子数组, arr [i]不得等于arr [j] 。如果它可以是有效的子数组,则其大小为2 。现在,尝试通过同时递减i和j来递增此子数组的大小,并且索引i之前和索引j之后的所有元素必须分别等于arr [i]和arr [j] 。打印到目前为止找到的最长的此类子数组的大小。
下面是上述方法的实现:
C++
// C++ implementation of the approach
#include
using namespace std;
// Function to return the maximum length
// of the required sub-array
int maxLength(int arr[], int n)
{
int maxLen = 0;
// For the first consecutive
// pair of elements
int i = 0;
int j = i + 1;
// While a consecutive pair
// can be selected
while (j < n) {
// If current pair forms a
// valid sub-array
if (arr[i] != arr[j]) {
// 2 is the length of the
// current sub-array
maxLen = max(maxLen, 2);
// To extend the sub-array both ways
int l = i - 1;
int r = j + 1;
// While elements at indices l and r
// are part of a valid sub-array
while (l >= 0 && r < n && arr[l] == arr[i]
&& arr[r] == arr[j]) {
l--;
r++;
}
// Update the maximum length so far
maxLen = max(maxLen, 2 * (r - j));
}
// Select the next consecutive pair
i++;
j = i + 1;
}
// Return the maximum length
return maxLen;
}
// Driver code
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
// Java implementation of the approach
class GFG {
// Function to return the maximum length
// of the required sub-array
static int maxLength(int arr[], int n)
{
int maxLen = 0;
// For the first consecutive
// pair of elements
int i = 0;
int j = i + 1;
// While a consecutive pair
// can be selected
while (j < n) {
// If current pair forms a
// valid sub-array
if (arr[i] != arr[j]) {
// 2 is the length of the
// current sub-array
maxLen = Math.max(maxLen, 2);
// To extend the sub-array both ways
int l = i - 1;
int r = j + 1;
// While elements at indices l and r
// are part of a valid sub-array
while (l >= 0 && r < n && arr[l] == arr[i] && arr[r] == arr[j]) {
l--;
r++;
}
// Update the maximum length so far
maxLen = Math.max(maxLen, 2 * (r - j));
}
// Select the next consecutive pair
i++;
j = i + 1;
}
// Return the maximum length
return maxLen;
}
// Driver code
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));
}
}
// This code is contributed by AnkitRai01
Python3
# Python3 implementation of the approach
# Function to return the maximum length
# of the required sub-array
def maxLength(arr, n):
maxLen = 0
# For the first consecutive
# pair of elements
i = 0
j = i + 1
# While a consecutive pair
# can be selected
while (j < n):
# If current pair forms a
# valid sub-array
if (arr[i] != arr[j]):
# 2 is the length of the
# current sub-array
maxLen = max(maxLen, 2)
# To extend the sub-array both ways
l = i - 1
r = j + 1
# While elements at indices l and r
# are part of a valid sub-array
while (l >= 0 and r < n and arr[l] == arr[i]
and arr[r] == arr[j]):
l-= 1
r+= 1
# Update the maximum length so far
maxLen = max(maxLen, 2 * (r - j))
# Select the next consecutive pair
i+= 1
j = i + 1
# Return the maximum length
return maxLen
# Driver code
arr =[1, 1, 1, 0, 0, 1, 1]
n = len(arr)
print(maxLength(arr, n))
# This code is contributed by mohit kumar 29
C#
// C# implementation of the approach
using System;
class GFG {
// Function to return the maximum length
// of the required sub-array
static int maxLength(int[] arr, int n)
{
int maxLen = 0;
// For the first consecutive
// pair of elements
int i = 0;
int j = i + 1;
// While a consecutive pair
// can be selected
while (j < n) {
// If current pair forms a
// valid sub-array
if (arr[i] != arr[j]) {
// 2 is the length of the
// current sub-array
maxLen = Math.Max(maxLen, 2);
// To extend the sub-array both ways
int l = i - 1;
int r = j + 1;
// While elements at indices l and r
// are part of a valid sub-array
while (l >= 0 && r < n && arr[l] == arr[i] && arr[r] == arr[j]) {
l--;
r++;
}
// Update the maximum length so far
maxLen = Math.Max(maxLen, 2 * (r - j));
}
// Select the next consecutive pair
i++;
j = i + 1;
}
// Return the maximum length
return maxLen;
}
// Driver code
public static void Main(String[] args)
{
int[] arr = { 1, 1, 1, 0, 0, 1, 1 };
int n = arr.Length;
Console.WriteLine(maxLength(arr, n));
}
}
// This code is contributed by 29AjayKumar
C++
// C++ implementation of the approach
#include
using namespace std;
// Function to return the maximum length
// of the required sub-array
int maxLength(int a[], int n)
{
// To store the maximum length
// for a valid subarray
int maxLen = 0;
// To store the count of contiguous
// similar elements for previous
// group and the current group
int prev_cnt = 0, curr_cnt = 1;
for (int i = 1; i < n; i++) {
// If current element is equal to
// the previous element then it is
// a part of the same group
if (a[i] == a[i - 1])
curr_cnt++;
// Else update the previus group
// and start counting elements
// for the new group
else {
prev_cnt = curr_cnt;
curr_cnt = 1;
}
// Update the maximum possible length for a group
maxLen = max(maxLen, min(prev_cnt, curr_cnt));
}
// Return the maximum length of the valid subarray
return (2 * maxLen);
}
// Driver code
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
// Java implementation of the approach
class GFG
{
// Function to return the maximum length
// of the required sub-array
static int maxLength(int a[], int n)
{
// To store the maximum length
// for a valid subarray
int maxLen = 0;
// To store the count of contiguous
// similar elements for previous
// group and the current group
int prev_cnt = 0, curr_cnt = 1;
for (int i = 1; i < n; i++)
{
// If current element is equal to
// the previous element then it is
// a part of the same group
if (a[i] == a[i - 1])
curr_cnt++;
// Else update the previus group
// and start counting elements
// for the new group
else
{
prev_cnt = curr_cnt;
curr_cnt = 1;
}
// Update the maximum possible length for a group
maxLen = Math.max(maxLen,
Math.min(prev_cnt, curr_cnt));
}
// Return the maximum length
// of the valid subarray
return (2 * maxLen);
}
// Driver code
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));
}
}
// This code is contributed by Rajput-Ji
Python3
# Python3 implementation of the approach
# Function to return the maximum length
# of the required sub-array
def maxLength(a, n):
# To store the maximum length
# for a valid subarray
maxLen = 0;
# To store the count of contiguous
# similar elements for previous
# group and the current group
prev_cnt = 0; curr_cnt = 1;
for i in range(n):
# If current element is equal to
# the previous element then it is
# a part of the same group
if (a[i] == a[i - 1]):
curr_cnt += 1;
# Else update the previus group
# and start counting elements
# for the new group
else:
prev_cnt = curr_cnt;
curr_cnt = 1;
# Update the maximum possible
# length for a group
maxLen = max(maxLen, min(prev_cnt,
curr_cnt));
# Return the maximum length
# of the valid subarray
return (2 * maxLen);
# Driver code
arr = [ 1, 1, 1, 0, 0, 1, 1 ];
n = len(arr);
print(maxLength(arr, n));
# This code is contributed by Rajput-Ji
C#
// C# implementation of the approach
using System;
class GFG
{
// Function to return the maximum length
// of the required sub-array
static int maxLength(int[] a, int n)
{
// To store the maximum length
// for a valid subarray
int maxLen = 0;
// To store the count of contiguous
// similar elements for previous
// group and the current group
int prev_cnt = 0, curr_cnt = 1;
for (int i = 1; i < n; i++)
{
// If current element is equal to
// the previous element then it is
// a part of the same group
if (a[i] == a[i - 1])
curr_cnt++;
// Else update the previus group
// and start counting elements
// for the new group
else
{
prev_cnt = curr_cnt;
curr_cnt = 1;
}
// Update the maximum possible length for a group
maxLen = Math.Max(maxLen,
Math.Min(prev_cnt, curr_cnt));
}
// Return the maximum length
// of the valid subarray
return (2 * maxLen);
}
// Driver code
public static void Main()
{
int[] arr = { 1, 1, 1, 0, 0, 1, 1 };
int n = arr.Length;
Console.WriteLine(maxLength(arr, n));
}
}
// This code is contributed by Code_Mech.
4
替代方法:我们可以维持先前相似元素的最大长度,并尝试与下一个不同的连续元素形成子数组,并最大化子数组的长度。
以下是上述方法的实现:
C++
// C++ implementation of the approach
#include
using namespace std;
// Function to return the maximum length
// of the required sub-array
int maxLength(int a[], int n)
{
// To store the maximum length
// for a valid subarray
int maxLen = 0;
// To store the count of contiguous
// similar elements for previous
// group and the current group
int prev_cnt = 0, curr_cnt = 1;
for (int i = 1; i < n; i++) {
// If current element is equal to
// the previous element then it is
// a part of the same group
if (a[i] == a[i - 1])
curr_cnt++;
// Else update the previus group
// and start counting elements
// for the new group
else {
prev_cnt = curr_cnt;
curr_cnt = 1;
}
// Update the maximum possible length for a group
maxLen = max(maxLen, min(prev_cnt, curr_cnt));
}
// Return the maximum length of the valid subarray
return (2 * maxLen);
}
// Driver code
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
// Java implementation of the approach
class GFG
{
// Function to return the maximum length
// of the required sub-array
static int maxLength(int a[], int n)
{
// To store the maximum length
// for a valid subarray
int maxLen = 0;
// To store the count of contiguous
// similar elements for previous
// group and the current group
int prev_cnt = 0, curr_cnt = 1;
for (int i = 1; i < n; i++)
{
// If current element is equal to
// the previous element then it is
// a part of the same group
if (a[i] == a[i - 1])
curr_cnt++;
// Else update the previus group
// and start counting elements
// for the new group
else
{
prev_cnt = curr_cnt;
curr_cnt = 1;
}
// Update the maximum possible length for a group
maxLen = Math.max(maxLen,
Math.min(prev_cnt, curr_cnt));
}
// Return the maximum length
// of the valid subarray
return (2 * maxLen);
}
// Driver code
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));
}
}
// This code is contributed by Rajput-Ji
Python3
# Python3 implementation of the approach
# Function to return the maximum length
# of the required sub-array
def maxLength(a, n):
# To store the maximum length
# for a valid subarray
maxLen = 0;
# To store the count of contiguous
# similar elements for previous
# group and the current group
prev_cnt = 0; curr_cnt = 1;
for i in range(n):
# If current element is equal to
# the previous element then it is
# a part of the same group
if (a[i] == a[i - 1]):
curr_cnt += 1;
# Else update the previus group
# and start counting elements
# for the new group
else:
prev_cnt = curr_cnt;
curr_cnt = 1;
# Update the maximum possible
# length for a group
maxLen = max(maxLen, min(prev_cnt,
curr_cnt));
# Return the maximum length
# of the valid subarray
return (2 * maxLen);
# Driver code
arr = [ 1, 1, 1, 0, 0, 1, 1 ];
n = len(arr);
print(maxLength(arr, n));
# This code is contributed by Rajput-Ji
C#
// C# implementation of the approach
using System;
class GFG
{
// Function to return the maximum length
// of the required sub-array
static int maxLength(int[] a, int n)
{
// To store the maximum length
// for a valid subarray
int maxLen = 0;
// To store the count of contiguous
// similar elements for previous
// group and the current group
int prev_cnt = 0, curr_cnt = 1;
for (int i = 1; i < n; i++)
{
// If current element is equal to
// the previous element then it is
// a part of the same group
if (a[i] == a[i - 1])
curr_cnt++;
// Else update the previus group
// and start counting elements
// for the new group
else
{
prev_cnt = curr_cnt;
curr_cnt = 1;
}
// Update the maximum possible length for a group
maxLen = Math.Max(maxLen,
Math.Min(prev_cnt, curr_cnt));
}
// Return the maximum length
// of the valid subarray
return (2 * maxLen);
}
// Driver code
public static void Main()
{
int[] arr = { 1, 1, 1, 0, 0, 1, 1 };
int n = arr.Length;
Console.WriteLine(maxLength(arr, n));
}
}
// This code is contributed by Code_Mech.
4