📌  相关文章
📜  选择一个整数K,以使所有Array元素的K的异或值的最大值最小化

📅  最后修改于: 2021-04-29 16:32:07             🧑  作者: Mango

给定一个由N个非负整数组成的数组A ,任务是选择一个整数K ,以使所有数组元素的K异或值的最大值最小。换句话说,对于某些K值,找到Z的最小可能值,其中Z = max(A [i] xor K) ,0 <= i <= n-1。

例子:

方法:为了解决上述问题,我们将使用递归。我们将从递归函数的最高有效位开始。

  • 在递归步骤中,将元素分为两部分-一个部分打开当前位,另一部分关闭当前位。如果任何部分中没有单个元素,则可以选择K的特定位,以使最终的异或值在该位位置处为0(因为我们的目标是使该值最小化),然后继续进行下一个操作。位在下一个递归步骤中。
  • 如果两个部分都包含一些元素,则通过在该位位置放置0和1并在下一个递归调用中使用相应的部分来计算答案,来探索这两种可能性。

    answer_on是值,如果1被放置,并且如果0被放置在该位置(POS)answer_off是的值。由于两个部分都不为空,因此无论我们为K选择哪一位,都将2 pos加到最终值上。

    对于每个递归步骤:

下面是上述方法的实现:

C++
// C++ implementation to find Minimum
// possible value of the maximum xor
// in an array by choosing some integer
  
#include 
using namespace std;
  
// Function to calculate Minimum possible
// value of the Maximum XOR in an array
int calculate(vector& section, int pos)
{
    // base case
    if (pos < 0)
        return 0;
  
    // Divide elements into two sections
    vector on_section, off_section;
  
    // Traverse all elements of current
    // section and divide in two groups
    for (auto el : section) {
        if (((el >> pos) & 1) == 0)
            off_section.push_back(el);
  
        else
            on_section.push_back(el);
    }
  
    // Check if one of the sections is empty
    if (off_section.size() == 0)
        return calculate(on_section, pos - 1);
  
    if (on_section.size() == 0)
        return calculate(off_section, pos - 1);
  
    // explore both the possibilities using recursion
    return min(calculate(off_section, pos - 1),
               calculate(on_section, pos - 1))
           + (1 << pos);
}
  
// Function to calculate minimum XOR value
int minXorValue(int a[], int n)
{
    vector section;
    for (int i = 0; i < n; i++)
        section.push_back(a[i]);
  
    // Start recursion from the
    // most significant pos position
    return calculate(section, 30);
}
  
// Driver code
int main()
{
    int N = 4;
  
    int A[N] = { 3, 2, 5, 6 };
  
    cout << minXorValue(A, N);
  
    return 0;
}


Java
// Java implementation to find Minimum
// possible value of the maximum xor
// in an array by choosing some integer
import java.util.*;
  
class GFG{
  
// Function to calculate Minimum possible
// value of the Maximum XOR in an array
static int calculate(Vector section, int pos)
{
  
    // Base case
    if (pos < 0)
        return 0;
  
    // Divide elements into two sections
    Vector on_section = new Vector(), 
                   off_section = new Vector();
  
    // Traverse all elements of current
    // section and divide in two groups
    for(int el : section) 
    {
       if (((el >> pos) & 1) == 0)
           off_section.add(el);
       else
           on_section.add(el);
    }
  
    // Check if one of the sections is empty
    if (off_section.size() == 0)
        return calculate(on_section, pos - 1);
  
    if (on_section.size() == 0)
        return calculate(off_section, pos - 1);
  
    // Explore both the possibilities using recursion
    return Math.min(calculate(off_section, pos - 1),
                    calculate(on_section, pos - 1)) +
                             (1 << pos);
}
  
// Function to calculate minimum XOR value
static int minXorValue(int a[], int n)
{
    Vector section = new Vector();
  
    for(int i = 0; i < n; i++)
       section.add(a[i]);
  
    // Start recursion from the
    // most significant pos position
    return calculate(section, 30);
}
  
// Driver code
public static void main(String[] args)
{
    int N = 4;
    int A[] = { 3, 2, 5, 6 };
  
    System.out.print(minXorValue(A, N));
}
}
  
// This code is contributed by Princi Singh


Python3
# Python3 implementation to find Minimum
# possible value of the maximum xor
# in an array by choosing some integer
   
# Function to calculate Minimum possible
# value of the Maximum XOR in an array
  
def calculate(section, pos):
  
    # base case
    if (pos < 0):
        return 0
   
    # Divide elements into two sections
    on_section = []
    off_section = []
   
    # Traverse all elements of current
    # section and divide in two groups
    for el in section:
        if (((el >> pos) & 1) == 0):
            off_section.append(el)
   
        else:
            on_section.append(el)
   
    # Check if one of the sections is empty
    if (len(off_section) == 0):
        return calculate(on_section, pos - 1)
   
    if (len(on_section) == 0):
        return calculate(off_section, pos - 1)
   
    # explore both the possibilities using recursion
    return min(calculate(off_section, pos - 1),
               calculate(on_section, pos - 1))+ (1 << pos)
   
# Function to calculate minimum XOR value
def minXorValue(a, n):
    section = []
    for i in range( n):
        section.append(a[i]);
   
    # Start recursion from the
    # most significant pos position
    return calculate(section, 30)
   
# Driver code
if __name__ == "__main__":
    N = 4
   
    A = [ 3, 2, 5, 6 ]
   
    print(minXorValue(A, N))
   
# This code is contributed by chitranayal


C#
// C# implementation to find minimum
// possible value of the maximum xor
// in an array by choosing some integer
using System;
using System.Collections.Generic;
  
class GFG{
  
// Function to calculate minimum possible
// value of the maximum XOR in an array
static int calculate(List section, int pos)
{
      
    // Base case
    if (pos < 0)
        return 0;
  
    // Divide elements into two sections
    List on_section = new List(), 
             off_section = new List();
  
    // Traverse all elements of current
    // section and divide in two groups
    foreach(int el in section) 
    {
        if (((el >> pos) & 1) == 0)
            off_section.Add(el);
        else
            on_section.Add(el);
    }
  
    // Check if one of the sections is empty
    if (off_section.Count == 0)
        return calculate(on_section, pos - 1);
  
    if (on_section.Count == 0)
        return calculate(off_section, pos - 1);
  
    // Explore both the possibilities using recursion
    return Math.Min(calculate(off_section, pos - 1),
                    calculate(on_section, pos - 1)) +
                             (1 << pos);
}
  
// Function to calculate minimum XOR value
static int minXorValue(int []a, int n)
{
    List section = new List();
  
    for(int i = 0; i < n; i++)
       section.Add(a[i]);
  
    // Start recursion from the
    // most significant pos position
    return calculate(section, 30);
}
  
// Driver code
public static void Main(String[] args)
{
    int N = 4;
    int []A = { 3, 2, 5, 6 };
  
    Console.Write(minXorValue(A, N));
}
}
  
// This code is contributed by Princi Singh


输出:
5

时间复杂度: O(N * log(max(A i ))