给定两个由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 akhilsainiC#
// 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 输出：
14 22 34 50 54
时间复杂度： O(N)
辅助空间： O(N)
如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live