Maximum XOR of k Size Subset

Given an integer array arr[] of size n and an integer k. The task is to find the maximum XOR of the subset of size k from the given array arr[].

Examples:

Input: arr[] = [2, 5, 4, 1, 3, 7, 6, 8], k = 3
Output: 15 
Explanation: XOR of the elements of subset {2, 5, 8} is 15, which is the maximum possible.

Input: arr[] = [3, 4, 7, 7, 9], k = 3
Output: 14 
Explanation: XOR of the elements of subset {3, 4, 9} is 14, which is the maximum possible.

Input: arr[] = [3, 4, 7, 16, 9], k = 1
Output: 16
Explanation: We need to select subset of size 1, thus the element with maximum value is the answer, which is 16.

[Naive Approach] - Using Recursion - O(2 ^ n) Time and O(1) Space

The idea is to generate all possible subset of size k from the given array arr[], and find the one with XOR of its elements maximum. For each element, there two options, either include it into subset or exclude it. Firstly, exclude the element and move to the next one. Thereafter add the element in the current subset, and update the XOR. When the size of subset is k, check if the current XOR is greater than previous, if so, update the XOR value. At last return the maximum XOR.

Follow the below given step-by-step approach:

• Start with a recursive function that keeps track of the current index, the current XOR value, and the size of the current subset.
• If the size of the current subset reaches k, compare the XOR with the maximum XOR found so far and update if it's greater.
• If the current index reaches the end of the array, return from the recursion.
• Recur by excluding the current element and moving to the next index.
• Recur by including the current element, updating the XOR and size of the subset, then moving to the next index.
• Continue this process until all combinations of subsets of size k have been explored.
• Return the maximum XOR obtained among all valid subsets.

Below is given the implementation:

15

[Expected Approach] - Using Memoization

The above approach can be optimized using Memoization. The idea is to store the results in a 3d array memo, to avoid computing the same subproblem multiple times. Create an array memo of order n * k * x, where n is the size of array, k is the size of subset, and x is the maximum XOR value (we are using unordered map). Here memo[i][j][x] stores the maximum possible XOR such that there are j elements in the subset up to index i with XOR x.

Follow the below given step-by-step approach:

• Use a 3D memoization structure memo[i][j][x], where:
  • i is the current index in the array,
  • j is the current size of the subset being formed,
  • x is the current XOR value.
• Initialize the memoization structure using an unordered map to dynamically manage the possible XOR values.
• Define a recursive function that explores all combinations by either:
  • Skipping the current element, or
  • Including the current element, updating the XOR value and the count.
• Before processing a state, check if it already exists in the memoization structure. If it does, return the stored result.
• If the size of the subset becomes k, return the current XOR value as a potential candidate for the maximum.
• Continue exploring other combinations and update the memoization structure with the maximum XOR obtained from the current state.
• Finally, return the highest XOR value recorded during the exploration.

Below is given the implementation:

15

Time Complexity: O(n * k * x), where n is the size of array, k is the size of subset, and x is the maximum possible XOR.
Auxiliary Space: O(n * k * x)