通过用它们的按位 AND 替换这些对来最大化按位 AND 超过按位 XOR 的对的计数

给定一个由N 个正整数组成的数组arr[] ，用它们的按位 AND 值替换其按位 AND 超过按位 XOR 值的数组元素对。最后，计算可以从数组中生成的此类对的最大数量。

例子：

Input: arr[] = {12, 9, 15, 7}
Output: 2
Explanation:
Step 1: Select the pair {12, 15} and replace the pair by their Bitwise AND (= 12). The array arr[] modifies to {12, 9, 7}. 
Step 2: Replace the pair {12, 9} by their Bitwise AND (= 8). Therefore, the array arr[] modifies to {8, 7}. 
Therefore, the maximum number of such pairs is 2.

Input: arr[] = {2, 6, 12, 18, 9}
Output: 1

朴素的方法：解决这个问题的最简单的方法是生成所有可能的对，并选择一个按位 AND 大于它们的按位 XOR 的对。替换这对并插入它们的按位 AND 。重复上述过程，直到找不到这样的对。打印获得的此类对的计数。
时间复杂度： O(N ³ )
辅助空间： O(1)

高效的方法：上述方法可以基于以下观察进行优化：

• 最高有效位在第i^个位置的数字只能与其他在第i^个位置具有MSB 的数字形成一对。
• 如果选择了这些对中的一个，则MSB在第i^个位置的数字的总数减少一。
• 因此，可以在^第i^个位置上形成的总对是具有MB编号的在i中的总计数^个位置下降1。

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

• 初始化一个映射，比如freq ，以存储在各个位位置具有 MSB 的数字的计数。
• 遍历数组，对于每个数组元素arr[i] ，找到arr[i]的 MSB 并将freq中 MSB 的计数增加1 。
• 初始化一个变量，比如对，以存储总对的数量。
• 遍历地图并将对更新为对 += (freq[i] – 1) 。
• 完成上述步骤后，打印pairs的值作为结果。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Function to count the number of
// pairs whose Bitwise AND is
// greater than the Bitwise XOR
int countPairs(int arr[], int N)
{
    // Stores the frequency of
    // MSB of array elements
    unordered_map freq;
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // Increment count of numbers
        // having MSB at log(arr[i])
        freq[log2(arr[i])]++;
    }
 
    // Stores total number of pairs
    int pairs = 0;
 
    // Traverse the Map
    for (auto i : freq) {
        pairs += i.second - 1;
    }
 
    // Return total count of pairs
    return pairs;
}
 
// Driver Code
int main()
{
    int arr[] = { 12, 9, 15, 7 };
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << countPairs(arr, N);
 
    return 0;
}

Java

// C# program for the above approach
import java.util.*;
class GFG {
 
  // Function to count the number of
  // pairs whose Bitwise AND is
  // greater than the Bitwise XOR
  static int countPairs(int[] arr, int N)
  {
 
    // Stores the frequency of
    // MSB of array elements
    HashMap freq
      = new HashMap();
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
      // Increment count of numbers
      // having MSB at log(arr[i])
      if (freq.containsKey((int)(Math.log(arr[i]))))
        freq.put((int)(Math.log(arr[i])),
                 (int)(Math.log(arr[i])) + 1);
      else
        freq.put((int)(Math.log(arr[i])), 1);
    }
 
    // Stores total number of pairs
    int pairs = 0;
 
    // Traverse the Map
    for (Map.Entry item :
         freq.entrySet())
 
    {
      pairs += item.getValue() - 1;
    }
 
    // Return total count of pairs
    return pairs;
  }
 
  // Driver Code
  public static void main(String[] args)
  {
    int[] arr = { 12, 9, 15, 7 };
    int N = arr.length;
    System.out.println(countPairs(arr, N));
  }
}
 
// This code is contributed by ukasp.

Python3

# Python3 program for the above approach
from math import log2
 
# Function to count the number of
# pairs whose Bitwise AND is
# greater than the Bitwise XOR
def countPairs(arr, N):
   
    # Stores the frequency of
    # MSB of array elements
    freq = {}
 
    # Traverse the array
    for i in range(N):
 
        # Increment count of numbers
        # having MSB at log(arr[i])
        x = int(log2(arr[i]))
        freq[x] = freq.get(x, 0) + 1
 
    # Stores total number of pairs
    pairs = 0
 
    # Traverse the Map
    for i in freq:
        pairs += freq[i] - 1
 
    # Return total count of pairs
    return pairs
 
# Driver Code
if __name__ == '__main__':
    arr = [12, 9, 15, 7]
    N = len(arr)
    print(countPairs(arr, N))
 
    # This code is contributed by mohit kumar 29.

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG
{
 
// Function to count the number of
// pairs whose Bitwise AND is
// greater than the Bitwise XOR
static int countPairs(int []arr, int N)
{
   
    // Stores the frequency of
    // MSB of array elements
    Dictionary freq = new Dictionary();
 
    // Traverse the array
    for (int i = 0; i < N; i++)
    {
 
        // Increment count of numbers
        // having MSB at log(arr[i])
        if(freq.ContainsKey((int)(Math.Log(Convert.ToDouble(arr[i]),2.0))))
         freq[(int)(Math.Log(Convert.ToDouble(arr[i]),2.0))]++;
        else
          freq[(int)(Math.Log(Convert.ToDouble(arr[i]),2.0))] = 1;
    }
 
    // Stores total number of pairs
    int pairs = 0;
 
    // Traverse the Map
    foreach(var item in freq)
    {
        pairs += item.Value - 1;
    }
 
    // Return total count of pairs
    return pairs;
}
 
// Driver Code
public static void Main()
{
    int []arr = { 12, 9, 15, 7 };
    int N =  arr.Length;
    Console.WriteLine(countPairs(arr, N));
}
}
 
// This code is contributed by SURENDRA_GANGWAR.

Javascript

 
// Javascript program for the above approach
 
// Function to count the number of
// pairs whose Bitwise AND is
// greater than the Bitwise XOR
function countPairs(arr, N)
{
    // Stores the frequency of
    // MSB of array elements
    var freq = new Map();
 
    // Traverse the array
    for (var i = 0; i < N; i++) {
 
        // Increment count of numbers
        // having MSB at log(arr[i])
        if(freq.has(parseInt(Math.log2(arr[i]))))
        {
            freq.set(parseInt(Math.log2(arr[i])), freq.get(parseInt(Math.log2(arr[i])))+1);
        }
        else
        {
            freq.set(parseInt(Math.log2(arr[i])), 1);
        }
    }
 
    // Stores total number of pairs
    var pairs = 0;
 
    // Traverse the Map
    freq.forEach((value,key) => {
        pairs += value - 1;
    });
 
    // Return total count of pairs
    return pairs;
}
 
// Driver Code
var arr = [12, 9, 15, 7 ];
var N = arr.length;
document.write( countPairs(arr, N));
 

输出：

2

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

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