从两个给定数组生成的对的所有按位与的最小可能按位或

给定两个阵列的常用3 []和BRR [分别的长度N和M]，创建使用以下操作，使得在阵列RES所有元素的按位或[]是最小的长度为N的阵列RES []。

• 对于arr []中的每个索引i，从数组brr []中选择任何索引j (允许重复)并更新res [i] = arr [i]和brr [j]

任务是打印数组元素res []的最小可能按位或的值。

例子：

Input: arr[] = {2, 1}, brr[] = {4, 6, 7} 
Output: 0 
Explanation: 
For the array arr[] = {2, 1}, choose the values from brr[] as {4, 4} or {4, 6}. 
Therefore, the resultant array becomes {0, 0} and the bitwise OR of the resultant array = 0 which is the minimum possible value.

Input: arr[] = {1, 2, 3}, brr[] = {7, 15} 
Output: 3 
Explanation: 
For the array arr[] = {1, 2, 3}, choose the values from brr[] as {7, 7, 7}. 
Therefore, the resultant array becomes {1, 2, 3} and the bitwise OR of the resultant array = 3.

天真的方法：最简单的方法是使用brr []生成数组arr []的所有可能对的按位或。完成上述步骤后，仅选择按位或为最小的N个元素。打印最小的按位或。

时间复杂度： O(2 ^{(N * M)} )
辅助空间： O(1)

高效的方法：为了优化上述方法，我们的想法是从最大可能的答案开始，然后在每个步骤中将其最小化。步骤如下：

1. 初始化最大可能答案(例如ans )，该答案将是一个数字，其中所有位均已设置。
2. 遍历从31到0的每个位，并检查该位是否可以置位，因为将特定位设置为0将使总体答案最小。
3. 对于上述步骤中的每个未设置位，请检查结果数组中的所有元素是否都将按位或作为当前可能的答案。如果发现是正确的，则以最小答案更新当前答案。
4. 完成上述步骤后，打印存储在ans中的Bitwise最小可能值。

下面是上述方法的实现。

C++

// C++ program for the above approach
 
#include 
#define ll long long
using namespace std;
 
// Function to check if it is possible
// to make current no as minimum result
// using array a and b
bool check(ll no, vector& a,
        vector& b)
{
    int count = 0;
 
    // Size of the first array
    int n = a.size();
 
    // Size of the second array
    int m = b.size();
 
    for (int i = 0; i < n; ++i) {
 
        for (int j = 0; j < m; ++j) {
 
            // Check for the number as
            // ans is possible or not
            if (((a[i] & b[j]) | no) == no) {
                count++;
                break;
            }
        }
    }
 
    // If all the elements of array
    // gives no as the Bitwise OR
    if (count == n)
        return true;
    else
        return false;
}
 
// Function to find the minimum bitwise
// OR of all the element in res[]
ll findMinValue(vector& a,
                vector& b)
{
    // Max possible ans
    ll ans = (1LL << 31) - 1;
 
    for (ll i = 30; i >= 0; --i) {
 
        // Check for the upper bit that
        // can be make off or not
        if (check(ans ^ (1 << i), a, b)) {
            ans = ans ^ (1 << i);
        }
    }
 
    return ans;
}
 
// Driver Code
int main()
{
    // Given array a[] and b[]
    vector a = { 1, 2, 3 };
    vector b = { 7, 15 };
 
    // Function Call
    cout << findMinValue(a, b);
 
    return 0;
}

Java

// Java program for
// the above approach
import java.util.*;
class GFG{
 
// Function to check if it is possible
// to make current no as minimum result
// using array a and b
static boolean check(int no,
                     int []a, int []b)
{
  int count = 0;
 
  // Size of the first array
  int n = a.length;
 
  // Size of the second array
  int m = b.length;
 
  for (int i = 0; i < n; ++i)
  {
    for (int j = 0; j < m; ++j)
    {
      // Check for the number as
      // ans is possible or not
      if (((a[i] & b[j]) | no) == no)
      {
        count++;
        break;
      }
    }
  }
 
  // If all the elements of array
  // gives no as the Bitwise OR
  if (count == n)
    return true;
  else
    return false;
}
 
// Function to find the minimum
// bitwise OR of all the
// element in res[]
static int findMinValue(int []a,
                        int []b)
{
  // Max possible ans
  int ans = (1 << 31) - 1;
 
  for (int i = 30; i >= 0; --i)
  {
    // Check for the upper bit that
    // can be make off or not
    if (check(ans ^ (1 << i), a, b))
    {
      ans = ans ^ (1 << i);
    }
  }
 
  return ans;
}
 
// Driver Code
public static void main(String[] args)
{
  // Given array a[] and b[]
  int []a = {1, 2, 3};
  int []b = {7, 15};
 
  // Function Call
  System.out.print(findMinValue(a, b));
}
}
 
// This code is contributed by shikhasingrajput

Python3

# Python3 program for the above approach
 
# Function to check if it is possible
# to make current no as minimum result
# using array a and b
def check(no, a, b):
     
    count = 0
 
    # Size of the first array
    n = len(a)
 
    # Size of the second array
    m = len(b)
 
    for i in range(n):
        for j in range(m):
 
            # Check for the number as
            # ans is possible or not
            if (((a[i] & b[j]) | no) == no):
                count += 1
                break
 
    # If athe elements of array
    # gives no as the Bitwise OR
    if (count == n):
        return True
    else:
        return False
 
# Function to find the minimum bitwise
# OR of athe element in res[]
def findMinValue(a, b):
     
    # Max possible ans
    ans = (1 << 31) - 1
 
    for i in range(30, -1, -1):
 
        # Check for the upper bit that
        # can be make off or not
        if (check(ans ^ (1 << i), a, b)):
            ans = ans ^ (1 << i)
 
    return ans
 
# Driver Code
if __name__ == '__main__':
     
    # Given array a[] and b[]
    a = [ 1, 2, 3 ]
    b = [ 7, 15 ]
 
    # Function call
    print(findMinValue(a, b))
 
# This code is contributed by mohit kumar 29

C#

// C# program for the above approach
using System;
 
class GFG{
 
// Function to check if it is possible
// to make current no as minimum result
// using array a and b
static bool check(int no, int []a,
                          int []b)
{
    int count = 0;
     
    // Size of the first array
    int n = a.Length;
     
    // Size of the second array
    int m = b.Length;
     
    for(int i = 0; i < n; ++i)
    {
        for(int j = 0; j < m; ++j)
        {
             
            // Check for the number as
            // ans is possible or not
            if (((a[i] & b[j]) | no) == no)
            {
                count++;
                break;
            }
        }
    }
     
    // If all the elements of array
    // gives no as the Bitwise OR
    if (count == n)
        return true;
    else
        return false;
}
 
// Function to find the minimum
// bitwise OR of all the
// element in res[]
static int findMinValue(int []a,
                        int []b)
{
     
    // Max possible ans
    int ans = int.MaxValue;
     
    for(int i = 30; i >= 0; --i)
    {
         
        // Check for the upper bit that
        // can be make off or not
        if (check(ans ^ (1 << i), a, b))
        {
            ans = ans ^ (1 << i);
        }
    }
    return ans;
}
 
// Driver Code
public static void Main(String[] args)
{
     
    // Given array []a and []b
    int []a = { 1, 2, 3 };
    int []b = { 7, 15 };
     
    // Function call
    Console.Write(findMinValue(a, b));
}
}
 
// This code is contributed by Amit Katiyar

Javascript

 
// JavaScript program to implement
// the above approach
 
// Function to check if it is possible
// to make current no as minimum result
// using array a and b
function check(no,
                     a, b)
{
  let count = 0;
  
  // Size of the first array
  let n = a.length;
  
  // Size of the second array
  let m = b.length;
  
  for (let i = 0; i < n; ++i)
  {
    for (let j = 0; j < m; ++j)
    {
      // Check for the number as
      // ans is possible or not
      if (((a[i] & b[j]) | no) == no)
      {
        count++;
        break;
      }
    }
  }
  
  // If all the elements of array
  // gives no as the Bitwise OR
  if (count == n)
    return true;
  else
    return false;
}
  
// Function to find the minimum
// bitwise OR of all the
// element in res[]
function findMinValue(a,b)
{
  // Max possible ans
  let ans = (1 << 31) - 1;
  
  for (let i = 30; i >= 0; --i)
  {
    // Check for the upper bit that
    // can be make off or not
    if (check(ans ^ (1 << i), a, b))
    {
      ans = ans ^ (1 << i);
    }
  }
  
  return ans;
}
 
// Driver code
 
    // Given array a[] and b[]
  let a = [1, 2, 3];
  let b = [7, 15];
  
  // Function Call
  document.write(findMinValue(a, b));
     
  // This code is contributed by target_2.      

输出：

3

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