给定两个大小为N的二进制数组X []和Y [] ，任务是通过选择奇数长度的任何子数组并从数组中翻转所有奇数索引元素的最小操作数，将数组X []转换为数组Y [] 。子数组。
例子：
Input: X[] = {1, 0, 0, 0, 0, 1}, Y[] = {1, 1, 0, 1, 1, 1}
Output: 2
Explanation:
Initially, X[] is {1, 0, 0, 0, 0, 1}.
Operation 1: Choose the sub-array {0, 0, 0} from array X[] and change the 2nd and 4th character and convert it to {1, 0, 1}.
Now X becomes {1, 1, 0, 1, 0, 1}.
Operation 2: Choose the sub-array {0} containing only the 5th character and convert it to 1.
Finally, X becomes {1, 1, 0, 1, 1, 1}, which is equal to Y.
Therefore, the count of operations is 2.
Input: X[] = {0, 1, 0}, Y[] = {0, 1, 0}
Output: 0
Explanation:
Since both the arrays X and Y are equal thus the minimum operations would be 0.
方法：想法是分别计算偶数和奇数位置的操作。请按照以下步骤解决问题：
- 将变量C初始化为0以存储操作计数。
- 在奇数位置遍历数组X []元素，并获得一个计数器计数= 0。
- 检查X [i]和Y [i]之间是否存在连续的不相等元素，并每次将计数器计数增加1 。
- 当X [i]和Y [i]相等时，将全局C增大以使运算增加1，因为在一个运算中，所有奇数位置都可以等于Y。
- 类似地，遍历偶数位置的数组X []元素，并再次获得计数器计数= 0。
- 检查X [i]和Y [i]之间的连续不相等元素，并每次将计数器计数增加1 。
- 当X [i]和Y [i]相等时，增加全局计数器C，以将操作增加1 。
- 完成上述步骤后，打印C的值作为所需操作的结果计数。
下面是上述方法的实现：
C++
// C++ program for the above approach
#include
using namespace std;
// Function to find the minimum flip
// of subarrays required at alternate
// index to make binary arrays equals
void minOperation(int X[], int Y[],
int n)
{
// Stores count of total operations
int C = 0;
// Stores count of consecutive
// unequal elements
int count = 0;
// Loop to run on odd positions
for (int i = 1; i < n; i = i + 2) {
if (X[i] != Y[i]) {
count++;
}
else {
// Incrementing the
// global counter
if (count != 0)
C++;
// Change count to 0
count = 0;
}
}
// If all last elements are equal
if (count != 0)
C++;
count = 0;
// Loop to run on even positions
for (int i = 0; i < n; i = i + 2) {
if (X[i] != Y[i]) {
count++;
}
else {
// Incrementing the
// global counter
if (count != 0)
C++;
// Change count to 0
count = 0;
}
}
if (count != 0)
C++;
// Print the minimum operations
cout << C;
}
// Driver Code
int main()
{
int X[] = { 1, 0, 0, 0, 0, 1 };
int Y[] = { 1, 1, 0, 1, 1, 1 };
int N = sizeof(X) / sizeof(X[0]);
// Function Call
minOperation(X, Y, N);
return 0;
} Java
// Java program for the above approach
import java.util.*;
class GFG{
// Function to find the minimum flip
// of subarrays required at alternate
// index to make binary arrays equals
static void minOperation(int X[], int Y[],
int n)
{
// Stores count of total operations
int C = 0;
// Stores count of consecutive
// unequal elements
int count = 0;
// Loop to run on odd positions
for(int i = 1; i < n; i = i + 2)
{
if (X[i] != Y[i])
{
count++;
}
else
{
// Incrementing the
// global counter
if (count != 0)
C++;
// Change count to 0
count = 0;
}
}
// If all last elements are equal
if (count != 0)
C++;
count = 0;
// Loop to run on even positions
for(int i = 0; i < n; i = i + 2)
{
if (X[i] != Y[i])
{
count++;
}
else
{
// Incrementing the
// global counter
if (count != 0)
C++;
// Change count to 0
count = 0;
}
}
if (count != 0)
C++;
// Print the minimum operations
System.out.print(C);
}
// Driver Code
public static void main(String[] args)
{
int X[] = { 1, 0, 0, 0, 0, 1 };
int Y[] = { 1, 1, 0, 1, 1, 1 };
int N = X.length;
// Function Call
minOperation(X, Y, N);
}
}
// This code is contributed by susmitakundugoaldangaPython3
# Python program for the above approach
# Function to find the minimum flip
# of subarrays required at alternate
# index to make binary arrays equals
def minOperation(X, Y, n):
# Stores count of total operations
C = 0;
# Stores count of consecutive
# unequal elements
count = 0;
# Loop to run on odd positions
for i in range(1, n, 2):
if (X[i] != Y[i]):
count += 1;
else:
# Incrementing the
# global counter
if (count != 0):
C += 1;
# Change count to 0
count = 0;
# If all last elements are equal
if (count != 0):
C += 1;
count = 0;
# Loop to run on even positions
for i in range(0, n, 2):
if (X[i] != Y[i]):
count += 1;
else:
# Incrementing the
# global counter
if (count != 0):
C += 1;
# Change count to 0
count = 0;
if (count != 0):
C += 1;
# Prthe minimum operations
print(C);
# Driver Code
if __name__ == '__main__':
X = [1, 0, 0, 0, 0, 1];
Y = [1, 1, 0, 1, 1, 1];
N = len(X);
# Function Call
minOperation(X, Y, N);
# This code is contributed by 29AjayKumarC#
// C# program for the above approach
using System;
class GFG{
// Function to find the minimum flip
// of subarrays required at alternate
// index to make binary arrays equals
static void minOperation(int []X, int []Y,
int n)
{
// Stores count of total operations
int C = 0;
// Stores count of consecutive
// unequal elements
int count = 0;
// Loop to run on odd positions
for(int i = 1; i < n; i = i + 2)
{
if (X[i] != Y[i])
{
count++;
}
else
{
// Incrementing the
// global counter
if (count != 0)
C++;
// Change count to 0
count = 0;
}
}
// If all last elements are equal
if (count != 0)
C++;
count = 0;
// Loop to run on even positions
for(int i = 0; i < n; i = i + 2)
{
if (X[i] != Y[i])
{
count++;
}
else
{
// Incrementing the
// global counter
if (count != 0)
C++;
// Change count to 0
count = 0;
}
}
if (count != 0)
C++;
// Print the minimum operations
Console.Write(C);
}
// Driver Code
public static void Main(String[] args)
{
int []X = { 1, 0, 0, 0, 0, 1 };
int []Y = { 1, 1, 0, 1, 1, 1 };
int N = X.Length;
// Function Call
minOperation(X, Y, N);
}
}
// This code is contributed by Amit Katiyar输出：
2时间复杂度： O(N)
辅助空间： O(1)