所需的最小子阵列反转，使得所有相邻元素对的总和为奇数

给定一个大小为N的数组arr[] ，具有相等数量的偶数和奇数整数，任务是找到需要反转的最小子数组数，以使相邻元素对的总和为奇数。

例子：

Input: arr[] = {13, 2, 6, 8, 3, 5, 7, 10, 14, 15} 
Output: 3
Explanation:
Step 1: Reverse subarray [2, 4] to modify the array to {13, 2, 3, 8, 6, 5, 7, 10, 14, 15}
Step 2: Reverse subarray [4, 5] to modify the array to {13, 2, 3, 8, 5, 6, 7, 10, 14, 15}
Step 3: Reverse subarray [8, 9] to modify the array to {13, 2, 3, 8, 5, 6, 7, 10, 15, 14}
After the above reversals, the sum of all adjacent element pairs is odd.
Therefore, the minimum reversals required is 3.

Input: arr[] = {1, 3, 4, 5, 9, 6, 8}
Output: 2

处理方法：使相邻元素之和为奇数，其思想是将元素以奇偶或偶奇的方式排列。要最小化反转操作的次数，请观察给定数组的以下属性：

• 如果有任何长度为M的子数组具有相同奇偶校验的所有元素，那么也存在一个长度为M的子数组，它具有所有相反奇偶校验的元素，因为数组中偶数和奇数元素的计数相同。
• 因此，生成交替奇偶校验长度为M的子数组所需的反转操作次数为(M – 1) 。

请按照以下步骤解决问题：

• 遍历给定数组，求数组中每个连续相同的奇偶元素所需的子数组反转次数。
• 令连续奇数和偶数元素的反转次数分别为cntOdd和cntEven 。
• 最小反转计数由cntOdd和cntEven的最大值给出，因为任务是删除所有连续的相同元素和需要删除的最大连续元素。

下面是上述方法的实现：

C++14

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to count reversals to
// separate elements with same parity
int separate(int arr[], int n, int parity)
{
    int count = 1, res = 0;
 
    // Traverse the given array
    for (int i = 1; i < n; i++) {
 
        // Count size of subarray having
        // integers with same parity only
        if (((arr[i] + parity) & 1)
            && ((arr[i - 1] + parity) & 1))
            count++;
 
        // Otherwise
        else {
 
            // Reversals required is equal
            // to one less than subarray size
            if (count > 1)
                res += count - 1;
 
            count = 1;
        }
    }
 
    // Return the total reversals
    return res;
}
 
// Function to print the array elements
void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}
 
// Function to count the mimimum reversals
// required to make make sum
// of all adjacent elements odd
void requiredOps(int arr[], int N)
{
    // Stores operations required for
    // separating adjacent odd elements
    int res1 = separate(arr, N, 0);
 
    // Stores operations required for
    // separating adjacent even elements
    int res2 = separate(arr, N, 1);
 
    // Maximum of two is the return
    cout << max(res1, res2);
}
 
// Driver Code
int main()
{
    // Given array arr[]
    int arr[] = { 13, 2, 6, 8, 3, 5,
                  7, 10, 14, 15 };
 
    // Size of array
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    requiredOps(arr, N);
 
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
   
// Function to count reversals to
// separate elements with same parity
static int separate(int arr[], int n, 
                    int parity)
{
    int count = 1, res = 0;
     
    // Traverse the given array
    for(int i = 1; i < n; i++)
    {
         
        // Count size of subarray having
        // integers with same parity only
        if (((arr[i] + parity) & 1) != 0 &&
            ((arr[i - 1] + parity) & 1) != 0)
            count++;
 
        // Otherwise
        else
        {
             
            // Reversals required is equal
            // to one less than subarray size
            if (count > 1)
                res += count - 1;
 
            count = 1;
        }
    }
 
    // Return the total reversals
    return res;
}
 
// Function to print the array elements
void printArray(int arr[], int n)
{
    for(int i = 0; i < n; i++)
        System.out.println(arr[i] + " ");
}
 
// Function to count the mimimum reversals
// required to make make sum
// of all adjacent elements odd
static void requiredOps(int arr[], int N)
{
     
    // Stores operations required for
    // separating adjacent odd elements
    int res1 = separate(arr, N, 0);
 
    // Stores operations required for
    // separating adjacent even elements
    int res2 = separate(arr, N, 1);
 
    // Maximum of two is the return
    System.out.print(Math.max(res1, res2));
}
 
// Driver Code
public static void main(String args[])
{
     
    // Given array arr[]
    int arr[] = { 13, 2, 6, 8, 3, 5,
                  7, 10, 14, 15 };
                   
    // Size of array
    int N = arr.length;
     
    // Function Call
    requiredOps(arr, N);
}
}
 
// This code is contributed by ipg2016107

Python3

# Python3 program for the
# above approach
 
# Function to count reversals
# to separate elements with
# same parity
def separate(arr, n, parity):
 
    count = 1
    res = 0
 
    # Traverse the given array
    for i in range(1, n):
 
        # Count size of subarray
        # having integers with
        # same parity only
        if (((arr[i] + parity) & 1) and
            ((arr[i - 1] + parity) & 1)):
            count += 1
 
        # Otherwise
        else:
 
            # Reversals required is
            # equal to one less than
            # subarray size
            if (count > 1):
                res += count - 1
 
            count = 1
 
    # Return the total
    # reversals
    return res
 
# Function to print the
# array elements
def printArray(arr, n):
 
    for i in range(n):
        print(arr[i],
              end = " ")
 
# Function to count the mimimum
# reversals required to make
# make sum of all adjacent
# elements odd
def requiredOps(arr, N):
 
    # Stores operations required
    # for separating adjacent
    # odd elements
    res1 = separate(arr, N, 0)
 
    # Stores operations required
    # for separating adjacent
    # even elements
    res2 = separate(arr, N, 1)
 
    # Maximum of two is the
    # return
    print(max(res1, res2))
 
# Driver Code
if __name__ == "__main__":
 
    # Given array arr[]
    arr = [13, 2, 6, 8, 3, 5,
           7, 10, 14, 15]
 
    # Size of array
    N = len(arr)
 
    # Function Call
    requiredOps(arr, N)
 
# This code is contributed by Chitranayal

C#

// C# program for the above approach
using System;
  
class GFG{
  
// Function to count reversals to
// separate elements with same parity
static int separate(int[] arr, int n, 
                    int parity)
{
    int count = 1, res = 0;
      
    // Traverse the given array
    for(int i = 1; i < n; i++)
    {
         
        // Count size of subarray having
        // integers with same parity only
        if (((arr[i] + parity) & 1) != 0 &&
            ((arr[i - 1] + parity) & 1) != 0)
            count++;
  
        // Otherwise
        else
        {
             
            // Reversals required is equal
            // to one less than subarray size
            if (count > 1)
                res += count - 1;
  
            count = 1;
        }
    }
  
    // Return the total reversals
    return res;
}
  
// Function to print the array elements
void printArray(int[] arr, int n)
{
    for(int i = 0; i < n; i++)
        Console.Write(arr[i] + " ");
}
  
// Function to count the mimimum reversals
// required to make make sum
// of all adjacent elements odd
static void requiredOps(int[] arr, int N)
{
      
    // Stores operations required for
    // separating adjacent odd elements
    int res1 = separate(arr, N, 0);
  
    // Stores operations required for
    // separating adjacent even elements
    int res2 = separate(arr, N, 1);
  
    // Maximum of two is the return
    Console.Write(Math.Max(res1, res2));
}
 
// Driver code
public static void Main()
{
     
    // Given array arr[]
    int[] arr = { 13, 2, 6, 8, 3, 5,
                  7, 10, 14, 15 };
                    
    // Size of array
    int N = arr.Length;
      
    // Function Call
    requiredOps(arr, N);
}
}
 
// This code is contributed by sanjoy_62

Javascript

 
// JavaScript program to implement
// the above approach
 
// Function to count reversals to
// separate elements with same parity
function separate(arr, n, parity)
{
    let count = 1, res = 0;
      
    // Traverse the given array
    for(let i = 1; i < n; i++)
    {
          
        // Count size of subarray having
        // letegers with same parity only
        if (((arr[i] + parity) & 1) != 0 &&
            ((arr[i - 1] + parity) & 1) != 0)
            count++;
  
        // Otherwise
        else
        {
              
            // Reversals required is equal
            // to one less than subarray size
            if (count > 1)
                res += count - 1;
  
            count = 1;
        }
    }
  
    // Return the total reversals
    return res;
}
  
// Function to prlet the array elements
function prletArray(arr, n)
{
    for(let i = 0; i < n; i++)
        document.write(arr[i] + " ");
}
  
// Function to count the mimimum reversals
// required to make make sum
// of all adjacent elements odd
function requiredOps( arr, N)
{
      
    // Stores operations required for
    // separating adjacent odd elements
    let res1 = separate(arr, N, 0);
  
    // Stores operations required for
    // separating adjacent even elements
    let res2 = separate(arr, N, 1);
  
    // Maximum of two is the return
    document.write(Math.max(res1, res2));
}
 
// Driver Code
 
    // Given array arr[]
    let arr = [ 13, 2, 6, 8, 3, 5,
                  7, 10, 14, 15 ];
                    
    // Size of array
    let N = arr.length;
      
    // Function Call
    requiredOps(arr, N);
      

输出：

3

时间复杂度： O(N)
辅助空间： O(1)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。