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

📌 相关文章

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

📅 最后修改于: 2021-05-17 23:50:14 🧑 作者: Mango

给定大小为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和cntE的最大值给出，因为任务是删除所有连续的相同元素，并且需要删除的最大连续数。

下面是上述方法的实现：

C++14

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to count reversals to
// seperate 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
// seperate 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 seperate 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
// seperate 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

输出：

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