最小化数组元素的按位异或与 1 需要使数组的总和至少为 K

给定一个由N 个正整数和一个正整数K组成的数组arr[] ，任务是计算需要1的数组元素的最小按位异或，使得数组的总和至少为 K 。

例子：

Input: arr[] = {0, 1, 1, 0, 1}, K = 4
Output: 1
Explanation: Performing Bitwise XOR of arr[0] and 1 modifies arr[] to {1, 1, 1, 0, 1}. Now, the sum of array = 1 + 1 + 1 + 0 + 1 = 4(= K).

Input: arr[] = {14, 0, 1, 0}, K = 20
Output: -1

方法：给定的问题可以使用以下事实来解决，即1与偶数元素的按位异或将元素增加1 。
请按照以下步骤解决问题：

• 找到给定数组arr[]的总和并将其存储在一个变量中，比如S 。
• 计算数组中偶数元素的数量并将其存储在一个变量中，比如E 。
• 如果S大于或等于K ，则打印0 。
• 否则，如果S + E 的值小于K ，则打印-1 。
• 否则，打印(K – S)的值作为数组元素与1的按位异或的最小数量是必需的。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to find minimum number
// of Bitwise XOR of array elements
// with 1 required to make sum of
// the array at least K
int minStepK(int arr[], int N, int K)
{
    // Stores the count of
    // even array elements
    int E = 0;
 
    // Stores sum of the array
    int S = 0;
 
    // Traverse the array arr[]
    for (int i = 0; i < N; i++) {
 
        // Increment sum
        S += arr[i];
 
        // If array element is even
        if (arr[i] % 2 == 0)
 
            // Increase count of even
            E += 1;
    }
 
    // If S is at least K
    if (S >= K)
        return 0;
 
    // If S + E is less than K
    else if (S + E < K)
        return -1;
 
    // Otherwise, moves = K - S
    else
        return K - S;
}
 
// Driver Code
int main()
{
    int arr[] = { 0, 1, 1, 0, 1 };
    int N = sizeof(arr) / sizeof(arr[0]);
    int K = 4;
    cout << minStepK(arr, N, K);
 
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
     
// Function to find minimum number
// of Bitwise XOR of array elements
// with 1 required to make sum of
// the array at least K
static int minStepK(int arr[], int N, int K)
{
     
    // Stores the count of
    // even array elements
    int E = 0;
 
    // Stores sum of the array
    int S = 0;
 
    // Traverse the array arr[]
    for(int i = 0; i < N; i++)
    {
         
        // Increment sum
        S += arr[i];
 
        // If array element is even
        if (arr[i] % 2 == 0)
 
            // Increase count of even
            E += 1;
    }
 
    // If S is at least K
    if (S >= K)
        return 0;
 
    // If S + E is less than K
    else if (S + E < K)
        return -1;
 
    // Otherwise, moves = K - S
    else
        return K - S;
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 0, 1, 1, 0, 1 };
    int N = arr.length;
    int K = 4;
     
    System.out.println(minStepK(arr, N, K));
}
}
 
// This code is contributed by offbeat

Python3

# Python 3 program for the above approach
 
# Function to find minimum number
# of Bitwise XOR of array elements
# with 1 required to make sum of
# the array at least K
def minStepK(arr, N, K):
 
    # Stores the count of
    # even array elements
    E = 0
 
    # Stores sum of the array
    S = 0
 
    # Traverse the array arr[]
    for i in range(N):
 
        # Increment sum
        S += arr[i]
 
        # If array element is even
        if (arr[i] % 2 == 0):
 
            # Increase count of even
            E += 1
 
    # If S is at least K
    if (S >= K):
        return 0
 
    # If S + E is less than K
    elif (S + E < K):
        return -1
 
    # Otherwise, moves = K - S
    else:
        return K - S
 
# Driver Code
if __name__ == "__main__":
 
    arr = [0, 1, 1, 0, 1]
    N = len(arr)
    K = 4
    print(minStepK(arr, N, K))
 
    # This code is contributed by ukasp.

C#

// C# program for the above approach
using System;
class GFG
{
   
// Function to find minimum number
// of Bitwise XOR of array elements
// with 1 required to make sum of
// the array at least K
static int minStepK(int[] arr, int N, int K)
{
     
    // Stores the count of
    // even array elements
    int E = 0;
 
    // Stores sum of the array
    int S = 0;
 
    // Traverse the array arr[]
    for(int i = 0; i < N; i++)
    {
         
        // Increment sum
        S += arr[i];
 
        // If array element is even
        if (arr[i] % 2 == 0)
 
            // Increase count of even
            E += 1;
    }
 
    // If S is at least K
    if (S >= K)
        return 0;
 
    // If S + E is less than K
    else if (S + E < K)
        return -1;
 
    // Otherwise, moves = K - S
    else
        return K - S;
}
 
    // Driver Code
    public static void Main()
    {
    int[] arr= { 0, 1, 1, 0, 1 };
    int N = arr.Length;
    int K = 4;
     
    Console.WriteLine(minStepK(arr, N, K));
 
    }
}
 
// This code is contributed by sanjoy_62.

Javascript

 
// JavaScript program for the above approach
 
// Function to find minimum number
// of Bitwise XOR of array elements
// with 1 required to make sum of
// the array at least K
function minStepK(arr, N, K)
{
     
    // Stores the count of
    // even array elements
    var E = 0;
     
    // Stores sum of the array
    var S = 0;
     
    // Traverse the array arr[]
    for(var i = 0; i < N; i++)
    {
         
        // Increment sum
        S += arr[i];
         
        // If array element is even
        if (arr[i] % 2 === 0)
         
            // Increase count of even
            E += 1;
    }
     
    // If S is at least K
    if (S >= K)
        return 0;
         
    // If S + E is less than K
    else if (S + E < K)
        return -1;
         
    // Otherwise, moves = K - S
    else
        return K - S;
}
 
// Driver Code
var arr = [ 0, 1, 1, 0, 1 ];
var N = arr.length;
var K = 4;
 
document.write(minStepK(arr, N, K));
 
// This code is contributed by rdtank
 

输出：

1

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

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live