# 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 ```

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 ``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<

## 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

 ``
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 ``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 > count(sz + 1, vector<``int``>(maxOR + 1, 1e9));``  ` `    ``count = 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