最小化交换以重新排列数组，以便索引和相应元素的奇偶校验相同

给定数组A[]，查找修改给定数组 A[] 所需的最小交换操作的任务，使得对于数组中的每个索引， parity(i) = parity(A[i]) where parity(x) = ×%2 。如果不可能获得这样的安排，则打印 -1。

例子：

Input: A[] = { 2, 4, 3, 1, 5, 6 } 
Output: 2 
Explanation: 
Swapping (4, 3) and (5, 6) modifies the array to [2, 3, 4, 1, 6, 5] such that the parity of i and A[i] is same for all indices.

Input: A[] = {1, 2, 5, 7} 
Output: -1 
Explanation: 
The given array cannot be rearranged as per required condition.

方法：
要解决上述问题，最佳方法是选择这样一个索引，其中parity(i)和parity(A[i])不相同。

• 将两个变量needodd和needeven初始化为0 ，这将存储每个元素的奇偶校验。检查索引的奇偶校验，如果它是奇数，则将needodd值增加 1，否则增加needeven 。
• 如果needodd和needeven不相同，则所需的安排是不可能的。
• 否则，最终结果由needodd变量获得，因为它是所需的操作次数。这是因为，在任何时候，我们都会选择奇偶校验与其索引的奇偶校验不同的奇数元素，并类似地选择一个偶数元素并交换它们。

下面是上述方法的实现：

C++

// C++ implementation to minimize
// swaps required to rearrange
// array such that parity of index and
// corresponding element is same
#include 
using namespace std;
 
// Function to return the
// parity of number
int parity(int x)
{
    return x % 2;
     
}
 
// Function to return minimum
// number of operations required
int solve(int a[], int size)
{
     
    // Initialize needodd and
    // needeven value by 0
    int needeven = 0;
    int needodd = 0;
     
    for(int i = 0; i < size; i++)
    {
        if(parity(i) != parity(a[i]))
        {
             
            // Check if parity(i) is odd
            if(parity(i) % 2)
            {
                 
                // increase needodd
                // as we need odd no
                // at that position.
                needodd++;
            }
            else
            {
 
                // increase needeven
                // as we need even
                // number at that position
                needeven++;
            }
        }
    }
     
    // If needeven and needodd are unequal
    if(needeven != needodd)
        return -1;
    else
        return needodd;
}
 
// Driver Code
int main()
{
    int a[] = { 2, 4, 3, 1, 5, 6};
    int n = sizeof(a) / sizeof(a[0]);
 
    // Function call
    cout << solve(a, n) << endl;
 
    return 0;
}
 
// This code is contributed by venky07

Java

// Java implementation to minimize 
// swaps required to rearrange 
// array such that parity of index and 
// corresponding element is same
import java.util.*;
 
class GFG{
     
// Function to return the
// parity of number
static int parity(int x)
{
    return x % 2;
}
 
// Function to return minimum
// number of operations required
static int solve(int a[], int size)
{
     
    // Initialize needodd and
    // needeven value by 0
    int needeven = 0;
    int needodd = 0;
     
    for(int i = 0; i < size; i++)
    {
        if(parity(i) != parity(a[i]))
        {
             
            // Check if parity(i) is odd
            if(parity(i) % 2 == 1)
            {
                 
                // Increase needodd
                // as we need odd no
                // at that position.
                needodd++;
            }
            else
            {
                 
                // Increase needeven
                // as we need even
                // number at that position
                needeven++;
            }
        }
    }
     
    // If needeven and needodd are unequal
    if(needeven != needodd)
        return -1;
    else
        return needodd;
}
 
// Driver Code
public static void main (String[] args)
{
    int a[] = { 2, 4, 3, 1, 5, 6};
    int n = a.length;
     
    // Function call
    System.out.println(solve(a, n));
}
}
 
// This code is contributed by offbeat

Python3

# Python3 implementation to minimize
# swaps required to rearrange
# array such that parity of index and
# corresponding element is same
 
# Function to return the
# parity of number
def parity(x):
    return x % 2
 
# Function to return minimum
# number of operations required
 
def solve(a, size):
     
    # Initialize needodd and
    # needeven value by 0
    needeven = 0
    needodd = 0
    for i in range(size):
                 
        if parity(i)!= parity(a[i]):
             
            # Check if parity(i) is odd
            if parity(i) % 2:
                 
                # increase needodd
                # as we need odd no
                # at that position.
                needodd+= 1
            else:
                # increase needeven
                # as we need even
                # number at that position
                needeven+= 1
     
    # If needeven and needodd are unequal
    if needodd != needeven:
        return -1
         
    return needodd
     
# Driver code    
if __name__ =="__main__":
     
    a = [2, 4, 3, 1, 5, 6]
    n = len(a)
    print(solve(a, n))

C#

// C# implementation to minimize 
// swaps required to rearrange 
// array such that parity of index and 
// corresponding element is same
using System;
class GFG{
     
// Function to return the
// parity of number
static int parity(int x)
{
  return x % 2;
}
 
// Function to return minimum
// number of operations required
static int solve(int[] a, int size)
{    
  // Initialize needodd and
  // needeven value by 0
  int needeven = 0;
  int needodd = 0;
 
  for(int i = 0; i < size; i++)
  {
    if(parity(i) != parity(a[i]))
    {
      // Check if parity(i) is odd
      if(parity(i) % 2 == 1)
      {
        // Increase needodd
        // as we need odd no
        // at that position.
        needodd++;
      }
      else
      {
        // Increase needeven
        // as we need even
        // number at that position
        needeven++;
      }
    }
  }
 
  // If needeven and needodd are unequal
  if(needeven != needodd)
    return -1;
  else
    return needodd;
}
 
// Driver Code
public static void Main ()
{
  int[] a = {2, 4, 3, 1, 5, 6};
  int n = a.Length;
 
  // Function call
  Console.Write(solve(a, n));
}
}
 
// This code is contributed by Chitranayal

Javascript

 
// Javascript implementation to minimize
// swaps required to rearrange array such
// that parity of index and corresponding
// element is same
 
// Function to return the
// parity of number
function parity(x)
{
    return x % 2;
}
 
// Function to return minimum
// number of operations required
function solve(a, size)
{
     
    // Initialize needodd and
    // needeven value by 0
    let needeven = 0;
    let needodd = 0;
     
    for(let i = 0; i < size; i++)
    {
        if (parity(i) != parity(a[i]))
        {
             
            // Check if parity(i) is odd
            if (parity(i) % 2 == 1)
            {
                 
                // Increase needodd
                // as we need odd no
                // at that position.
                needodd++;
            }
            else
            {
                 
                // Increase needeven
                // as we need even
                // number at that position
                needeven++;
            }
        }
    }
     
    // If needeven and needodd are unequal
    if (needeven != needodd)
        return -1;
    else
        return needodd;
}
 
// Driver code
let a = [ 2, 4, 3, 1, 5, 6 ];
let n = a.length;
 
// Function call
document.write(solve(a, n));
 
// This code is contributed by rameshtravel07
 

输出：

2

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live