范围 [L, R] 中最多 K 个元素的最小异或

给定三个整数L 、 R和K ，任务是找到[L, R]之间最多 K个整数的最小按位异或。

例子：

Input: L = 1, R = 10, K = 3
Output: 0
Explanation:
Choose elements 4, 5, and 1 in the range [1, 10] and the Bitwise XOR of the chosen elements is 0, which is minimum.

Input: L = 32, R = 33, K = 2
Output: 1
Explanation:
Choose elements 32, and 33 in the range [32, 33] and the Bitwise XOR of the chosen elements is 1, which is minimum.

编程需要懂一点英语

方法：有助于我们解决问题的一个观察是两个数字X的按位异或，如果X是偶数，则(X+1)为1 。因此，如果第一个是偶数，则四个连续数字的按位异或将为0 。

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

如果K的值大于4 ，则答案始终为 0。 （这是因为始终可以在5其中X是偶数。）
如果K的值为2 ，则调用函数func2()接受L, R , 和K作为输入参数并执行以下操作：
- 如果(RL)的值大于或等于2 ，即范围内至少有3 个数字，则返回1 。（这是因为两个数字X和X+1总是可以在3的范围内找到，其中X是偶数。）
- 否则，返回L和(L^R) 的最小值。
如果K的值为3 ，则调用函数func3()接受L, R , 和K作为输入参数并执行以下操作：
- 如果(R^L)位于L和R之间，则返回0 。（这是因为(R^L)^L^R=0) ）
- 否则，返回func2(L, R, K)
如果K的值为4 ，则调用函数func4()接受L, R , 和K作为输入参数并执行以下操作：
- 如果(RL)大于或等于4 ，即范围内至少有5 个数字，则返回0。（这是因为四个数字X,(X+1),(X+2)和 (X+ 3)总是可以在5的范围内找到，其中X是偶数。）
- 否则，返回范围 [L, R]和func3(L, R, K)中四个数字的 Xor的最小值。
否则，返回L。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
// Function for K=2
int func2(int L, int R, int K)
{
    if (R - L >= 2)
        return 1;
    return min(L, L ^ R);
}
// Function for K=2
int func3(int L, int R, int K)
{
    if ((R ^ L) > L && (R ^ L) < R)
        return 0;
    return func2(L, R, K);
}
// Function for K=2
int func4(int L, int R, int K)
{
    if (R - L >= 4)
        return 0;
    int minval = L ^ (L + 1) ^ (L + 2) ^ (L + 3);
    return min(minval, func3(L, R, K));
}
// Function to calculate the minimum XOR of at most K
// elements in [L, R]
int minimumXor(int L, int R, int K)
{
    if (K > 4)
        return 0;
    else if (K == 4)
        return func4(L, R, K);
    else if (K == 3)
        return func3(L, R, K);
    else if (K == 2)
        return func2(L, R, K);
    else
        return L;
}
// Driver code
int main()
{
    // Input
    int L = 1, R = 3, K = 3;
    // Function call
    cout << minimumXor(L, R, K) << endl;
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
 
class GFG
{
 
// Function for K=2
static int func2(int L, int R, int K)
{
    if (R - L >= 2)
        return 1;
    return Math.min(L, L ^ R);
}
    
// Function for K=2
static int func3(int L, int R, int K)
{
    if ((R ^ L) > L && (R ^ L) < R)
        return 0;
    return func2(L, R, K);
}
    
// Function for K=2
static int func4(int L, int R, int K)
{
    if (R - L >= 4)
        return 0;
    int minval = L ^ (L + 1) ^ (L + 2) ^ (L + 3);
    return Math.min(minval, func3(L, R, K));
}
// Function to calculate the minimum XOR of at most K
// elements in [L, R]
static int minimumXor(int L, int R, int K)
{
    if (K > 4)
        return 0;
    else if (K == 4)
        return func4(L, R, K);
    else if (K == 3)
        return func3(L, R, K);
    else if (K == 2)
        return func2(L, R, K);
    else
        return L;
}
 
  // Driver code
  public static void main(String[] args)
  {
      // Input
    int L = 1, R = 3, K = 3;
    
    // Function call
    System.out.println( minimumXor(L, R, K));
  }
}
 
// This code is contributed by sanjoy_62.

Python3

# Python program for the above approach
 
# Function for K=2
def func2(L, R, K):
    if (R - L >= 2):
        return 1
    return min(L, L ^ R)
 
  # Function for K=2
def func3(L, R, K):
    if ((R ^ L) > L and (R ^ L) < R):
        return 0
    return func2(L, R, K)
   
# Function for K=2
def func4(L, R, K):
    if (R - L >= 4):
        return 0
    minval = L ^ (L + 1) ^ (L + 2) ^ (L + 3)
    return min(minval, func3(L, R, K))
   
# Function to calculate the minimum XOR of at most K
# elements in [L, R]
def minimumXor(L, R, K):
    if (K > 4):
        return 0
    elif (K == 4):
        return func4(L, R, K)
    elif (K == 3):
        return func3(L, R, K)
    elif (K == 2):
        return func2(L, R, K)
    else:
        return L
 
# Driver code
if __name__ == '__main__':
   
    # Input
    L, R, K = 1, 3, 3
     
    # Function call
    print (minimumXor(L, R, K))
 
# This code is contributed by mohit kumar 29.

C#

// C# program for the above approach
using System;
class GFG
{
 
// Function for K=2
static int func2(int L, int R, int K)
{
    if (R - L >= 2)
        return 1;
    return Math.Min(L, L ^ R);
}
   
// Function for K=2
static int func3(int L, int R, int K)
{
    if ((R ^ L) > L && (R ^ L) < R)
        return 0;
    return func2(L, R, K);
}
   
// Function for K=2
static int func4(int L, int R, int K)
{
    if (R - L >= 4)
        return 0;
    int minval = L ^ (L + 1) ^ (L + 2) ^ (L + 3);
    return Math.Min(minval, func3(L, R, K));
}
// Function to calculate the minimum XOR of at most K
// elements in [L, R]
static int minimumXor(int L, int R, int K)
{
    if (K > 4)
        return 0;
    else if (K == 4)
        return func4(L, R, K);
    else if (K == 3)
        return func3(L, R, K);
    else if (K == 2)
        return func2(L, R, K);
    else
        return L;
}
 
 
// Driver code
static void Main()
{
    // Input
    int L = 1, R = 3, K = 3;
   
    // Function call
    Console.Write( minimumXor(L, R, K));
 
}
}
 
// This code is contributed by code_hunt.

Javascript

输出

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