重新排列数组以使两个数组的相似索引元素的按位异或相同

给定两个由N 个整数（ N为奇数）组成的数组A[]和B[] ，任务是重新排列数组B[] ，使得对于每个1 ≤ i ≤ N ， A[i]和B[i 的按位异或]是一样的。如果没有这样的重新排列是可能的，打印“-1” 。否则，打印重新排列。

例子：

Input: A[] = {1, 2, 3, 4, 5}, B[] = {5, 4, 3, 2, 1}
Output: {1, 2, 3, 4, 5}
Explanation:
Rearranging the array B[] to {1, 2, 3, 4, 5}, Bitwise XOR between every corresponding pair of array elements is same i.e., 0.

Input: A[] = {14, 21, 33, 49, 53}, B[] = {54, 50, 34, 22, 14}
Output: -1

朴素的方法：最简单的方法是生成数组B[] 的所有可能排列，并打印与相应元素按位异或相同的数组组合。

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

高效的方法：这个想法是使用按位异或的交换属性。以下是步骤：

• 找到两个数组元素的按位异或，让值成为xor_value 。
• 将数组B[]元素的频率存储在映射M 中。
• 要重新排列B[]的数组元素，请遍历数组B[]并执行以下操作：
  • 将此数组的当前元素更新为A[i]^xor_value 。
  • 如果更新的当前元素的频率大于 1，则将其递减。
  • 否则，没有这种可能的安排，跳出循环，并打印“-1” 。
• 完成上述步骤后，打印数组B[]因为它包含重新排列的数组。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to rearrange the array
// B[] such that A[i] ^ B[i] is same
// for each element
vector rearrangeArray(
    vector& A, vector& B, int N)
{
    // Store frequency of elements
    map m;
 
    // Stores xor value
    int xor_value = 0;
 
    for (int i = 0; i < N; i++) {
 
        // Taking xor of all the
        // values of both arrays
        xor_value ^= A[i];
        xor_value ^= B[i];
 
        // Store frequency of B[]
        m[B[i]]++;
    }
 
    for (int i = 0; i < N; i++) {
 
        // Find the array B[] after
        // rearrangement
        B[i] = A[i] ^ xor_value;
 
        // If the updated value is
        // present then decrement
        // its frequency
        if (m[B[i]]) {
            m[B[i]]--;
        }
 
        // Otherwise return empty vector
        else
            return vector{};
    }
 
    return B;
}
 
// Utility function to rearrange the
// array B[] such that A[i] ^ B[i]
// is same for each element
void rearrangeArrayUtil(
    vector& A, vector& B, int N)
{
    // Store rearranged array B
    vector ans
        = rearrangeArray(A, B, N);
 
    // If rearrangement possible
    if (ans.size()) {
        for (auto x : ans) {
            cout << x << " ";
        }
    }
 
    // Otherwise return -1
    else {
        cout << "-1";
    }
}
 
// Driver Code
int main()
{
    // Given vector A
    vector A = { 13, 21, 33, 49, 53 };
 
    // Given vector B
    vector B = { 54, 50, 34, 22, 14 };
 
    // Size of the vector
    int N = (int)A.size();
 
    // Function Call
    rearrangeArrayUtil(A, B, N);
 
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.util.*;
 
class GFG{
 
// Function to rearrange the array
// B[] such that A[i] ^ B[i] is same
// for each element
static ArrayList rearrangeArray(
       ArrayList A,
       ArrayList B, int N)
{
     
    // Store frequency of elements
    HashMap m = new HashMap();
 
    // Stores xor value
    int xor_value = 0;
 
    for(int i = 0; i < N; i++)
    {
         
        // Taking xor of all the
        // values of both arrays
        xor_value ^= A.get(i);
        xor_value ^= B.get(i);
 
        // Store frequency of B[]
        m.put(B.get(i),
              m.getOrDefault(B.get(i) + 1, 0));
    }
 
    for(int i = 0; i < N; i++)
    {
         
        // Find the array B[] after
        // rearrangement
        B.set(i, A.get(i) ^ xor_value);
 
        // If the updated value is
        // present then decrement
        // its frequency
        if (m.getOrDefault(B.get(i), -1) != -1)
        {
            m.put(B.get(i),
                  m.getOrDefault(B.get(i), 0) - 1);
        }
 
        // Otherwise return empty vector
        else
            return (new ArrayList());
    }
    return B;
}
 
// Utility function to rearrange the
// array B[] such that A[i] ^ B[i]
// is same for each element
static void rearrangeArrayUtil(ArrayList A,
                               ArrayList B, int N)
{
     
    // Store rearranged array B
    ArrayList ans = rearrangeArray(A, B, N);
 
    // If rearrangement possible
    if (ans.size() != 0)
    {
        for(int i = 0; i < ans.size(); i++)
        {
            System.out.print(ans.get(i) + " ");
        }
    }
 
    // Otherwise return -1
    else
    {
        System.out.println("-1");
    }
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given vector A
    ArrayList A = new ArrayList(
        Arrays.asList(13, 21, 33, 49, 53));
 
    // Given vector B
    ArrayList B = new ArrayList(
        Arrays.asList(54, 50, 34, 22, 14));
 
    // Size of the vector
    int N = (int)A.size();
 
    // Function Call
    rearrangeArrayUtil(A, B, N);
}
}
 
// This code is contributed by akhilsaini

Python3

# Python3 program for the above approach
 
# Function to rearrange the array
# B[] such that A[i] ^ B[i] is same
# for each element
def rearrangeArray(A, B, N):
   
  # Store frequency of elements
  m = {}
 
  # Stores xor value
  xor_value = 0
 
  for i in range(0, N):
     
    # Taking xor of all the
    # values of both arrays
    xor_value ^= A[i]
    xor_value ^= B[i]
 
    # Store frequency of B[]
    if B[i] in m:
      m[B[i]] = m[B[i]] + 1
    else:
      m[B[i]] = 1
     
  for i in range(0, N):
     
    # Find the array B[] after
    # rearrangement
    B[i] = A[i] ^ xor_value
 
    # If the updated value is
    # present then decrement
    # its frequency
    if B[i] in m:
      m[B[i]] = m[B[i]] - 1
       
    # Otherwise return empty vector
    else:
      X = []
      return X
 
  return B
 
# Utility function to rearrange the
# array B[] such that A[i] ^ B[i]
# is same for each element
def rearrangeArrayUtil(A, B, N):
   
  # Store rearranged array B
  ans = rearrangeArray(A, B, N)
   
  # If rearrangement possible
  if (len(ans) > 0):
     for x in ans:
        print(x, end = ' ')
         
  # Otherwise return -1
  else:
    print("-1")
     
# Driver Code
if __name__ == '__main__':
   
  # Given vector A
  A = [ 13, 21, 33, 49, 53 ]
 
  # Given vector B
  B = [ 54, 50, 34, 22, 14 ]
 
  # Size of the vector
  N = len(A)
 
  # Function Call
  rearrangeArrayUtil(A, B, N)
   
# This code is contributed by akhilsaini

C#

// C# program for the above approach
using System;
using System.Collections;
using System.Collections.Generic;
 
class GFG{
 
// Function to rearrange the array
// B[] such that A[i] ^ B[i] is same
// for each element
static ArrayList rearrangeArray(ArrayList A,
                                ArrayList B, int N)
{
     
    // Store frequency of elements
    Dictionary m = new Dictionary();
 
    // Stores xor value
    int xor_value = 0;
 
    for(int i = 0; i < N; i++)
    {
         
        // Taking xor of all the
        // values of both arrays
        xor_value ^= (int)A[i];
        xor_value ^= (int)B[i];
 
        // Store frequency of B[]
        if (!m.ContainsKey((int)B[i]))
            m.Add((int)B[i], 1);
        else
            m[(int)B[i]] = m[(int)B[i]] + 1;
    }
 
    for(int i = 0; i < N; i++)
    {
         
        // Find the array B[] after
        // rearrangement
        B[i] = (int)A[i] ^ xor_value;
 
        // If the updated value is
        // present then decrement
        // its frequency
        if (m.ContainsKey((int)B[i]))
        {
            m[(int)B[i]]--;
        }
 
        // Otherwise return empty vector
        else
            return (new ArrayList());
    }
    return B;
}
 
// Utility function to rearrange the
// array B[] such that A[i] ^ B[i]
// is same for each element
static void rearrangeArrayUtil(ArrayList A,
                               ArrayList B,
                               int N)
{
     
    // Store rearranged array B
    ArrayList ans = rearrangeArray(A, B, N);
 
    // If rearrangement possible
    if (ans.Count != 0)
    {
        for(int i = 0; i < ans.Count; i++)
        {
            Console.Write(ans[i] + " ");
        }
    }
     
    // Otherwise return -1
    else
    {
        Console.WriteLine("-1");
    }
}
 
// Driver Code
public static void Main()
{
     
    // Given vector A
    ArrayList A = new ArrayList{ 13, 21, 33, 49, 53 };
 
    // Given vector B
    ArrayList B = new ArrayList{ 54, 50, 34, 22, 14 };
 
    // Size of the vector
    int N = A.Count;
 
    // Function Call
    rearrangeArrayUtil(A, B, N);
}
}
 
// This code is contributed by akhilsaini

Javascript

// Javascript program for the above approach
 
// Function to rearrange the array
// B[] such that A[i] ^ B[i] is same
// for each element
function rearrangeArray(A, B, N)
{
 
    // Store frequency of elements
    let m = new Map();
 
    // Stores xor value
    let xor_value = 0;
 
    for (let i = 0; i < N; i++) {
 
        // Taking xor of all the
        // values of both arrays
        xor_value ^= A[i];
        xor_value ^= B[i];
 
        // Store frequency of B[]
        if (m.has(B[i])) {
            m.set(B[i], m.get(B[i]) + 1)
        } else {
            m.set(B[i], 1)
        }
    }
 
    for (let i = 0; i < N; i++) {
 
        // Find the array B[] after
        // rearrangement
        B[i] = A[i] ^ xor_value;
 
        // If the updated value is
        // present then decrement
        // its frequency
        if (m.has(B[i])) {
            m.set(B[i], m.get(B[i]) - 1)
        }
 
        // Otherwise return empty vector
        else
            return [];
    }
 
    return B;
}
 
// Utility function to rearrange the
// array B[] such that A[i] ^ B[i]
// is same for each element
function rearrangeArrayUtil(A, B, N)
{
 
    // Store rearranged array B
    let ans = rearrangeArray(A, B, N);
 
    // If rearrangement possible
    if (ans.length > 0) {
        for (let x of ans) {
            document.write(x + " ");
        }
    }
 
    // Otherwise return -1
    else {
        document.write("-1");
    }
}
 
// Driver Code
 
// Given vector A
let A = [13, 21, 33, 49, 53];
 
// Given vector B
let B = [54, 50, 34, 22, 14];
 
// Size of the vector
let N = A.length;
 
// Function Call
rearrangeArrayUtil(A, B, N);
 
// This code is contributed by _saurabh_jaiswal.

输出：

14 22 34 50 54

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

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