检查 Array 是否可以重新排列，使得 arr[i] XOR arr[i+2] 为 0

给定一个大小为N的数组arr[] ，任务是检查数组元素是否可以重新排列，使得第 i和第(i+2) 个元素的按位异或对于任何i ( 0 ≤ i < N-2 )

例子：

Input: arr[] = {1, 1, 2, 2}, N = 4
Output: YES
Explanation: Rearrange the array like {1, 2, 1, 2}.
Here XOR of [1, 1] and XOR of [2, 2] is 0.

Input: arr[] = {1, 2, 3, 4}, N = 4
Output: NO
Explanation: Here no such arrangement is possible such that arr[i] XOR arr[i+2] is 0.

编程需要懂一点英语

朴素方法：朴素方法是以所有可能的方式重新排列数组，然后对每个排列检查是否满足给定条件。

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

高效的方法：这个问题可以基于以下思路来解决：

Bitwise XOR of two elements is 0 only when both the elements are same.
Based on the above observation it can be understood that all the elements in the odd position must be same and all the elements in the even position must be same

编程需要懂一点英语

因此，当只有一个唯一元素（因为所有元素都相同）或两个唯一元素并且它们的频率与数组的奇数和偶数位置的数量相同时，只有这样的重新排列才有可能。

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

创建一个 unordered_map 来计算唯一元素的数量。
遍历数组并将数组的元素存储在map中。
数数地图中不同类型元素的数量。
如果count > 2 ，则无法按交替位置重新排列数组。
如果count = 1 ，那么安排是可能的。
如果count = 2 ，则有两种可能性：
- 如果数组（ N ）的大小是偶数，那么两者的频率应该相同。
- 如果数组的大小是奇数，那么一个元素的频率应该是N/2而另一个应该是N/2+1 。

下面是上述方法的实现：

C++14

// C++ code to implement the approach
 
#include 
using namespace std;
 
// Function to check that rearrangment
// possible or not
bool find(int n, vector arr)
{
    // Declaring map
    unordered_map m;
    int count = 0;
 
    // Traversing array to check
    // the number of unique element
    for (int i = 0; i < n; i++) {
        m[arr[i]]++;
        if (m[arr[i]] == 1)
            count++;
    }
 
    // Checking the number of different
    // elements are greater than two or not
    if (count > 2) {
        return false;
    }
 
    else if (count == 0) {
        return false;
    }
    else {
 
        // If all the elements are same
        if (count == 1) {
            return true;
        }
        else {
 
            // If size is odd
            if (n % 2) {
                if (m[arr[0]] == n / 2
                    || m[arr[0]]
                           == (n / 2) + 1) {
                    return true;
                }
                else
                    return false;
            }
 
            // If size is even
            else {
                if (m[arr[0]] == n / 2)
                    return true;
                else
                    return false;
            }
        }
    }
    return false;
}
 
// Driver code
int main()
{
    // Size of Array
    int N = 4;
    vector arr{ 1, 1, 2, 2 };
 
    // Function call
    bool flag = find(N, arr);
    if (flag)
        cout << "YES";
    else
        cout << "NO";
    return 0;
}

Java

// Java code to implement the approach
import java.util.*;
 
class GFG {
 
  // Function to check that rearrangment
  // possible or not
  static boolean ans = false;
  static void  find(int n, int[] arr)
  {
     
    // Declaring map
    HashMap m = new HashMap<>();
    int count = 0;
 
    // Traversing array to check
    // the number of unique element
    for (int i = 0; i < n; i++) {
      if(m.containsKey(arr[i]))
        m.put(arr[i], m.get(arr[i]) + 1);
      if (m.get(arr[i]) == null)count = count;
      else count++;
    }
 
    // Checking the number of different
    // elements are greater than two or not
    if (count > 2) {
      ans = false;
      return;
    }
 
    else if (count == 0) {
      ans = false;
      return;
    }
    else {
 
      // If all the elements are same
      if (count == 1) {
        ans = true;
        return;
      }
      else {
 
        // If size is odd
        if (n % 2 == 1) {
          if (m.get(arr[0]) == n / 2
              || m.get(arr[0])
              == (n / 2) + 1) {
            ans = true;
            return;
          }
          else{
            ans = false;
            return;
          }
        }
 
        // If size is even
        else {
          if (m.get(arr[0])== n / 2){
            ans = true;
            return;
          }
          else{
            ans = false;
            return;
          }
        }
      }
    }
  }
 
  // Driver code
  public static void main (String[] args) {
    int N = 4;
    int arr[] = { 1, 1, 2, 2 };
 
    // Function call
    find(N, arr);
    boolean flag = ans;
    if (!flag)
      System.out.println("YES");
    else
      System.out.println("NO");
 
  }
}
 
// This code is contributed by hrithikgarg03188.

输出

YES

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