Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Size of the smallest subset with maximum Bitwise OR

  • Difficulty Level : Medium
  • Last Updated : 05 Nov, 2021

Given an array of positive integers. The task is to find the size of the smallest subset such that the Bitwise OR of that set is Maximum possible. 

Examples: 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input : arr[] = {5, 1, 3, 4, 2}
Output : 2
7 is the maximum value possible of OR, 
5|2 = 7 and 5|3 = 7

Input : arr[] = {2, 6, 2, 8, 4, 5}
Output : 3
15 is the maximum value of OR and set
elements are 8, 6, 5

Source: Sprinklr on Campus Internship 



Doing bitwise OR of a number with some value does not decrease its value. It either keeps the value same or increases. If we take a closer look at the problem we can notice that the maximum OR value that we can get is by doing bitwise OR of all array elements. But this includes all elements and here want to know the smallest subset. So we do the following. 
I) Find bitwise OR of all array elements. This is the OR we are looking for. 
II) Now we need to find the smallest subset with this bitwise OR. This problem is similar to the subset-sum problem, We can solve it in two ways : 

  1. We generate all subsets and return the smallest size with given OR
  2. We use Dynamic Programming to solve the problem. This solution is going to be very similar to Maximum size subset with given sum

The time complexity of the 1st solution is O(2n) and time complexity of the Dynamic Programming solution is O(OR * n) where OR is OR of all array elements and n is the size of the input array. 

Using Method 1 : (generating all subsets and return the smallest size with given OR) 

C++




// CPP Code for above approach
#include <bits/stdc++.h>
using namespace std;
 
// Compute bitwise or of all elements
// in array of size sz
int OR(int data[], int sz)
{
    int mOR = 0;
      for (int i = 0; i < sz; ++i) {
        mOR |= data[i];
    }
   
      return mOR;
}
 
// calculate the size of
// minimum subset with maximum or
int minSubset(int data[], int sz,int maxOR)
{
  // store the minimum size of
  // the subset with maximum OR
      int minSZ=sz;
   
      // generates all subsets
    for(int mask=0;mask<(1<<sz);mask++)
    {
      // stores the size of the current subset
      int curSZ=0;
      // stores the OR of all the elements
      // in the current subset
      int curOR=0;
        
      for(int i=0;i<sz;i++)
      {
        if(mask&(1<<i))
        {
          curSZ++;
          curOR|=data[i];
        }
      }
      if(curOR==maxOR)
        minSZ=min(minSZ,curSZ);
    }
   
  return minSZ;
}
 
// Driver code
int main()
{
    int data[] = { 5, 1, 3, 4, 2 };
    int sz = sizeof(data) / sizeof(0);
    int maxOR = OR(data, sz);
     
    // Function Call
    cout << minSubset(data, sz,maxOR) << '\n' ;
}
Java



// Java Program for above approach
import java.io.*;
import java.util.*;
 
class Solution
{
   
  // Compute bitwise or of all elements
  // in array of size sz
  private static int OR(int[] arr)
  {
    int mOR = 0;
    for (int i = 0; i < arr.length; ++i)
    {
      mOR |= arr[i];
    }
    return mOR;
  }
   
  // Recursively calculating the size of
  // minimum subset with maximum or
  private static int maxSubset(int[] arr, int i,
                int curOr, int curSize, int maxOr)
  {
       
    // If i is arr.length
    if (i == arr.length)
    {
       
      // If curOr is equal to maxOr
      if (curOr == maxOr)
      {
          return curSize;
      }
       
      // Return arr.length
      else
      {
          return arr.length;
      }
    }
     
    // Try the current element in the subset
    int take = maxSubset(arr, i + 1, curOr |
                          arr[i], curSize + 1, maxOr);
     
    // Skip the current element
    int notTake = maxSubset(arr, i + 1, curOr,
                                      curSize, maxOr);
     
     
    // Return minimum of take and notTake
    return Math.min(take, notTake);
  }
   
  // Driver Code
  public static void main(String[] args)
  {
    int[] data = {5, 1, 3, 4, 2};
     
    int maxOr = OR(data);
     
    // Function Call
    int maxSubsetSize = maxSubset(data, 0, 0, 0, maxOr);
    System.out.println(maxSubsetSize);
  }
}
 
// Code contributed by Abdelaziz EROUI
C#



// C# Program for above approach
using System;
class Solution
{
   
  // Compute bitwise or of all elements
  // in array of size sz
  private static int OR(int[] arr)
  {
    int mOR = 0;
    for (int i = 0; i < arr.Length; ++i)
    {
      mOR |= arr[i];
    }
    return mOR;
  }
   
  // Recursively calculating the size of
  // minimum subset with maximum or
  private static int maxSubset(int[] arr, int i,
                int curOr, int curSize, int maxOr)
  {
       
    // If i is arr.length
    if (i == arr.Length)
    {
       
      // If curOr is equal to maxOr
      if (curOr == maxOr)
      {
          return curSize;
      }
       
      // Return arr.length
      else
      {
          return arr.Length;
      }
    }
     
    // Try the current element in the subset
    int take = maxSubset(arr, i + 1, curOr |
                          arr[i], curSize + 1, maxOr);
     
    // Skip the current element
    int notTake = maxSubset(arr, i + 1, curOr,
                                      curSize, maxOr);
     
     
    // Return minimum of take and notTake
    return Math.Min(take, notTake);
  }
   
  // Driver Code
  static void Main()
  {
    int[] data = {5, 1, 3, 4, 2};
     
    int maxOr = OR(data);
     
    // Function Call
    int maxSubsetSize = maxSubset(data, 0, 0, 0, maxOr);
     Console.WriteLine(maxSubsetSize);
  }
}
 
// This code is contributed by SoumikMondal
Javascript



<script>
 
// JavaScript Program for above approach
 
// Compute bitwise or of all elements
  // in array of size sz
function OR(arr)
{
    let mOR = 0;
    for (let i = 0; i < arr.length; ++i)
    {
      mOR |= arr[i];
    }
    return mOR;
}
 
// Recursively calculating the size of
  // minimum subset with maximum or
function maxSubset(arr,i,curOr,curSize,maxOr)
{
    // If i is arr.length
    if (i == arr.length)
    {
        
      // If curOr is equal to maxOr
      if (curOr == maxOr)
      {
          return curSize;
      }
        
      // Return arr.length
      else
      {
          return arr.length;
      }
    }
      
    // Try the current element in the subset
    let take = maxSubset(arr, i + 1, curOr |
                          arr[i], curSize + 1, maxOr);
      
    // Skip the current element
    let notTake = maxSubset(arr, i + 1, curOr,
                                      curSize, maxOr);
      
      
    // Return minimum of take and notTake
    return Math.min(take, notTake);
}
 
// Driver Code
let data=[5, 1, 3, 4, 2];
let maxOr = OR(data);
 
// Function Call
let maxSubsetSize = maxSubset(data, 0, 0, 0, maxOr);
document.write(maxSubsetSize);
     
     
// This code is contributed by rag2127
 
</script>
Output
2

Time complexity: O(2n)
Auxiliary Space: O(n) 
Using Method 2: 
 We first find the OR of all elements of given array.Now we need to find the smallest subset with this bitwise OR.
To do so, use the similar DP approach as given in the subset sum problem. count[i][j] denotes the minimum size subset till ith element whose OR is j.
C++



// CPP Code for above approach
#include <bits/stdc++.h>
using namespace std;
 
// Compute bitwise or of all elements
// in array of size sz
int OR(int data[], int sz)
{
    int mOR = 0;
    for (int i = 0; i < sz; ++i) {
        mOR |= data[i];
    }
 
    return mOR;
}
 
// calculate the size of
// minimum subset with maximum or
int minSubset(int data[], int sz, int maxOR)
{
    // count table where
      // count[i][j] => minimum size subset till ith element
      // whose OR is j
    vector<vector<int> > count(sz + 1, vector<int>(maxOR + 1, 1e9));
   
    count[0][0] = 0;
 
    for (int i = 0; i < sz; i++) {
        for (int j = 0; j <= maxOR; j++) {
            // Do not consider ith element.
            count[i + 1][j] = min(count[i + 1][j], count[i][j]);
 
            // Consider the ith element.
            if (count[i][j] != 1e9) {
                count[i + 1][j | data[i]] = min(
                    count[i + 1][j | data[i]], count[i][j] + 1);
            }
        }
    }
 
    return count[sz][maxOR];
}
 
// Driver code
int main()
{
    int data[] = { 5, 1, 3, 4, 2 };
    int sz = sizeof(data) / sizeof(0);
    int maxOR = OR(data, sz);
 
    // Function Call
    cout << minSubset(data, sz, maxOR) << '\n';
}
Output
2

Time complexity: O(n*maxOR) where n is the size of the array and maxOR is the maximum or that can be obtained.
Auxiliary Space: O(n*maxOR) 



My Personal Notes
arrow_drop_up
Previous
Sprinklr On Campus Internship
Next

Maximum size subset with given sum
Recommended Articles
Page :
Find size of largest subset with bitwise AND greater than their bitwise XOR
25, Nov 21
Maximum size of subset such that product of all subset elements is a factor of N
27, Sep 21
Total pairs in an array such that the bitwise AND, bitwise OR and bitwise XOR of LSB is 1
07, May 19
Calculate Bitwise OR of two integers from their given Bitwise AND and Bitwise XOR values
02, Dec 20
Maximize count of pairs whose Bitwise AND exceeds Bitwise XOR by replacing such pairs with their Bitwise AND
22, Feb 21
Find the size of Largest Subset with positive Bitwise AND
27, Sep 21
Find maximum subset sum formed by partitioning any subset of array into 2 partitions with equal sum
08, Apr 20
Sum of maximum and minimum of Kth subset ordered by increasing subset sum
27, Sep 20
Split Array into K non-overlapping subset such that maximum among all subset sum is minimum
20, Jul 21
Maximize count of subsets having product of smallest element and size of the subset at least X
31, Aug 20
Maximum subset with bitwise OR equal to k
29, May 18
Find a non empty subset in an array of N integers such that sum of elements of subset is divisible by N
05, Jul 18
Largest possible Subset from an Array such that no element is K times any other element in the Subset
28, Jul 20
Find subsequences with maximum Bitwise AND and Bitwise OR
12, Nov 18
Split an array into subarrays with maximum Bitwise XOR of their respective Bitwise OR values
14, Jun 21
Smallest subset of maximum sum possible by splitting array into two subsets
21, Apr 21
Maximum size subset with given sum
29, Nov 17
Maximum size subset with given sum using Backtracking
02, Jul 20
Maximum size of subset of given array such that a triangle can be formed by any three integers as the sides of the triangle
27, Sep 21
Check if bitwise AND of any subset is power of two
10, Apr 18
Check whether bitwise AND of a number with any subset of an array is zero or not
23, Oct 18
Smallest element with K set bits such that sum of Bitwise AND of each array element with K is maximum
12, Apr 21
Count of N-size maximum sum Arrays with elements in range [0, 2^K – 1] and Bitwise AND equal to 0
09, Jul 21
Maximum sum of Bitwise XOR of elements with their respective positions in a permutation of size N
08, Feb 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Kushdeep_Mittal
@Kushdeep_Mittal
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox