📌  相关文章
📜  将数组划分为两个子集,最大子集与最小子集之间按位异或

📅  最后修改于: 2021-05-17 01:54:19             🧑  作者: Mango

给定大小为N的数组arr [] ,任务是将数组拆分为两个子集,以使第一子集的最大值与第二子集的最小值之间的按位XOR最小。

例子:

方法:想法是找到数组中的两个元素,以使两个数组元素之间的按位XOR最小。请按照以下步骤解决问题:

  • 初始化一个变量,例如minXOR ,以存储一个子集的最大元素与另一子集的最小元素之间的按位XOR的最小可能值。
  • 以升序对数组arr []进行排序。
  • 遍历数组并更新minXOR = min(minXOR,arr [i] ^ arr [i – 1])。

下面是上述方法的实现:

C++
// C++ program for the above approach
  
#include 
using namespace std;
  
// Function to split the array into two subset 
// such that the Bitwise XOR between the maximum
// of one subset and minimum of other is minimum
int splitArray(int arr[], int N)
{
    // Sort the array in 
    // increasing order
    sort(arr, arr + N);
  
    int result = INT_MAX;
  
    // Calculating the min Bitwise XOR
    // between consecutive elements
    for (int i = 1; i < N; i++) {
        result = min(result,
                     arr[i] - arr[i - 1]);
    }
  
    // Return the final
    // minimum Bitwise XOR
    return result;
}
  
  
// Driver Code
int main()
{
    // Given array arr[]
    int arr[] = { 3, 1, 2, 6, 4 };
  
    // Size of array
    int N = sizeof(arr) / sizeof(arr[0]);
  
    // Function Call
    cout << splitArray(arr, N);
    return 0;
}


Java
// java program for the above approach
import java.util.*; 
class GFG{
  
// Function to split the array into two subset 
// such that the Bitwise XOR between the maximum
// of one subset and minimum of other is minimum
static int splitArray(int arr[], int N)
{
    // Sort the array in
    // increasing order
    Arrays.sort(arr);
  
    int result = Integer.MAX_VALUE;
  
    // Calculating the min Bitwise XOR
    // between consecutive elements
    for (int i = 1; i < N; i++) 
    {
        result = Math.min(result,
                          arr[i] - arr[i - 1]);
    }
  
    // Return the final 
    // minimum Bitwise XOR
    return result;
}
  
// Driver Code
public static void main(String[] args) 
{ 
    // Given array arr[]
    int arr[] = { 3, 1, 2, 6, 4 };
  
    // Size of array
    int N = arr.length;
  
    // Function Call
    System.out.print(splitArray(arr, N));
}
}


Python3
# Python3 program for the above approach
  
# Function to split the array into two subset 
# such that the Bitwise XOR between the maximum
# of one subset and minimum of other is minimum
def splitArray(arr, N):
      
    # Sort the array in increasing
    # order
    arr = sorted(arr)
  
    result = 10 ** 9
  
    # Calculating the min Bitwise XOR
    # between consecutive elements
    for i in range(1, N):
        result = min(result, arr[i] ^ arr[i - 1])
  
    # Return the final 
    # minimum Bitwise XOR
    return result
  
# Driver Code
if __name__ == '__main__':
      
    # Given array arr[]
    arr = [ 3, 1, 2, 6, 4 ]
  
    # Size of array
    N = len(arr)
  
    # Function Call
    print(splitArray(arr, N))
  
# This code is contributed by mohit kumar 29


C#
// C# program for the above approach
using System;
class GFG{
  
// Function to split the array into two subset 
// such that the Bitwise XOR between the maximum
// of one subset and minimum of other is minimum
static int splitArray(int []arr, int N)
{
    // Sort the array in increasing order
    Array.Sort(arr);
  
    int result = Int32.MaxValue;
  
    // Calculating the min Bitwise XOR
    // between consecutive elements
    for (int i = 1; i < N; i++) 
    {
        result = Math.Min(result,
                          arr[i] ^ arr[i - 1]);
    }
  
    // Return the final 
    // minimum Bitwise XOR
    return result;
}
  
// Driver Code
public static void Main() 
{ 
    // Given array arr[]
    int []arr = { 3, 1, 2, 6, 4 };
  
    // Size of array
    int N = arr.Length;
  
    // Function Call
    Console.Write(splitArray(arr, N));
}
}


输出:
1

时间复杂度: O(N * log N)
辅助空间: O(1)