排列 Array 使得所有相邻元素的乘积是偶数

给定一个由N 个正整数组成的数组arr[] ，任务是找到给定数组的任何排列，使得相邻元素的乘积是偶数。如果不可能，则打印任何此类排列或 -1。

例子：

Input: arr[] = {6,7,9,8,10,11}
Output: 8 9 10 7 6 11
Explanation: 
Product of adjacent elements =>
8 x 9 = 72 (even)
9 x 10 = 90 (even)
10 x 7 = 70 (even)
7 x 6 = 42 (even)
6 x 11 = 66 (even)

Input: arr[] = {3,2,5,7,1,4,9}
Output: -1
Explanation: There is no possible arrangements of elements such that product of adjacent elements is equal.

朴素的方法：解决这个问题的最简单的方法是尝试所有可能的元素排列并检查条件是否为真。

时间复杂度： O(N*N!) 其中 N 是数组中元素的数量。 O(N!) 是创建给定数组的所有排列所花费的时间，O(N) 是检查当前排列是否是所需排列所需的时间。
辅助空间： O(N) 来存储每次的排列。

有效的方法：可以使用简单的观察找到解决方案。如果数组中有多个奇数和偶数元素，那么任何相邻元素的最佳排列可以是以下任何一种情况，以使乘积为偶数：

{Odd, Even} 
{Even, Odd}
{Even, Even}

Please note that {Odd, Odd} arrangement of any adjacent element will give an Odd product. Hence, this arrangement is not possible. 

上述安排只有在以下情况下才有可能

number_of_odd_elements  <= number_of_even_elements + 1 in the array.

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

1. 取两个向量偶数和奇数分别存储数组的偶数和奇数元素。
2. 如果奇数向量的大小大于偶数向量的大小 + 1， （如上所述）那么解决方案是不可能的。因此，打印-1 。
3. 别的第一打印从奇数向量中的一个元素，然后从一个偶数矢量元件，直到两个向量是空的。

下面是上述方法的实现。

C++

// C++ program to Permutation of Array
// such that product of all
// adjacent elements is even
 
#include 
using namespace std;
 
// Function to print
// the required permutation
 
void printPermutation(int arr[], int n)
{
    vector odd, even;
 
    // push odd elements in 'odd'
    // and even elements in 'even'
    for (int i = 0; i < n; i++) {
 
        if (arr[i] % 2 == 0)
            even.push_back(arr[i]);
        else
            odd.push_back(arr[i]);
    }
 
    int size_odd = odd.size();
    int size_even = even.size();
 
    // Check if it possible to
    // arrange the elements
    if (size_odd > size_even + 1)
        cout << -1 << endl;
 
    // else print the permutation
    else {
 
        int i = 0;
        int j = 0;
 
        while (i < size_odd && j < size_even) {
 
            cout << odd[i] << " ";
            ++i;
            cout << even[j] << " ";
            ++j;
        }
 
        // Print remaining odds are even.
        // and even elements
        while (i < size_odd) {
            cout << odd[i] << " ";
            ++i;
        }
 
        while (j < size_even) {
            cout << even[j] << " ";
        }
    }
}
 
// Driver code
int main()
{
    int arr[] = { 6, 7, 9, 8, 10, 11 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    printPermutation(arr, N);
    return 0;
}

Java

// Java program to permutation of array
// such that product of all adjacent
// elements is even
import java.io.*;
import java.util.*;
 
class GFG{
     
// Function to print
// the required permutation
static void printPermutation(int arr[], int n)
{
    ArrayList odd = new ArrayList();
    ArrayList even = new ArrayList();
     
    // push odd elements in 'odd'
    // and even elements in 'even'
    for(int i = 0; i < n; i++)
    {
         if (arr[i] % 2 == 0)
              even.add(arr[i]);
           else
              odd.add(arr[i]);
    }
   
    int size_odd = odd.size();
    int size_even = even.size();
   
    // Check if it possible to
    // arrange the elements
    if (size_odd > size_even + 1)
        System.out.println("-1");
 
    // Else print the permutation
    else
    {
        int i = 0;
        int j = 0;
 
        while (i < size_odd && j < size_even)
        {
            System.out.print(odd.get(i) + " ");
            ++i;
            System.out.print(even.get(j) + " ");
            ++j;
        }
 
        // Print remaining odds are even.
        // and even elements
        while (i < size_odd)
        {
            System.out.print(odd.get(i) + " ");
            ++i;
        }
        while (j < size_even)
        {
            System.out.print(even.get(j) + " ");
        }
    }
}
 
// Driver Code
public static void main (String[] args)
{
    int arr[] = { 6, 7, 9, 8, 10, 11 };
    int N = arr.length;
 
    printPermutation(arr, N);
}
}
 
// This code is contributed by offbeat

Python3

# Python3 program to Permutation of Array
# such that product of all
# adjacent elements is even
 
# Function to print
# the required permutation
def printPermutation(arr, n):
 
    odd, even = [], []
 
    # push odd elements in 'odd'
    # and even elements in 'even'
    for i in range(n):
        if(arr[i] % 2 == 0):
            even.append(arr[i])
        else:
            odd.append(arr[i])
 
    size_odd = len(odd)
    size_even = len(even)
 
    # Check if it possible to
    # arrange the elements
    if(size_odd > size_even + 1):
        print(-1)
 
    # else print the permutation
    else:
        i, j = 0, 0
 
        while(i < size_odd and j < size_even):
             
            print(odd[i], end = " ")
            i += 1
            print(even[j], end = " ")
            j += 1
 
    # Print remaining odds are even.
    # and even elements
    while(i < size_odd):
        print(odd[i], end = " ")
        i += 1
 
    while(j < size_even):
        print(even[j], end = " ")
        j += 1
 
# Driver Code
arr = [ 6, 7, 9, 8, 10, 11 ]
 
N = len(arr)
 
# Function call
printPermutation(arr, N)
 
# This code is contributed by Shivam Singh

C#

// C# program to permutation of array
// such that product of all adjacent
// elements is even
using System;
using System.Collections.Generic;
 
class GFG{
     
// Function to print
// the required permutation
static void printPermutation(int []arr, int n)
{
    List odd = new List();
    List even = new List();
     
    // push odd elements in 'odd'
    // and even elements in 'even'
    for(int i = 0; i < n; i++)
    {
        if (arr[i] % 2 == 0)
            even.Add(arr[i]);
        else
            odd.Add(arr[i]);
    }
 
    int size_odd = odd.Count;
    int size_even = even.Count;
 
    // Check if it possible to
    // arrange the elements
    if (size_odd > size_even + 1)
        Console.WriteLine("-1");
 
    // Else print the permutation
    else
    {
        int i = 0;
        int j = 0;
 
        while (i < size_odd && j < size_even)
        {
            Console.Write(odd[i] + " ");
            ++i;
            Console.Write(even[j] + " ");
            ++j;
        }
 
        // Print remaining odds are even.
        // and even elements
        while (i < size_odd)
        {
            Console.Write(odd[i] + " ");
            ++i;
        }
        while (j < size_even)
        {
            Console.Write(even[j] + " ");
        }
    }
}
 
// Driver Code
public static void Main(String[] args)
{
    int []arr = { 6, 7, 9, 8, 10, 11 };
    int N = arr.Length;
 
    printPermutation(arr, N);
}
}
 
// This code is contributed by PrinciRaj1992

Javascript

 
// JavaScript program to permutation of array
// such that product of all adjacent
// elements is even
 
// Function to print
// the required permutation
function printPermutation(arr, n)
{
    let odd = [];
    let even = [];
       
    // push odd elements in 'odd'
    // and even elements in 'even'
    for(let i = 0; i < n; i++)
    {
        if (arr[i] % 2 == 0)
            even.push(arr[i]);
        else
            odd.push(arr[i]);
    }
   
    let size_odd = odd.length;
    let size_even = even.length;
   
    // Check if it possible to
    // arrange the elements
    if (size_odd > size_even + 1)
        document.write("-1");
   
    // Else prlet the permutation
    else
    {
        let i = 0;
        let j = 0;
   
        while (i < size_odd && j < size_even)
        {
            document.write(odd[i] + " ");
            ++i;
            document.write(even[j] + " ");
            ++j;
        }
   
        // Print remaining odds are even.
        // and even elements
        while (i < size_odd)
        {
            document.write(odd[i] + " ");
            ++i;
        }
        while (j < size_even)
        {
            document.write(even[j] + " ");
        }
    }
}
 
 
// Driver Code
 
    let arr = [ 6, 7, 9, 8, 10, 11 ];
    let N = arr.length;
   
    printPermutation(arr, N);
      

输出

7 6 9 8 11 10 

时间复杂度： O(N)，其中 N 是元素的数量。遍历给定数组并形成奇数和偶数向量需要 O(N) 时间，打印排列需要 O(N) 时间。
辅助空间： O(N) 因为给定的数组元素分布在两个向量中。

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