Skip to content
Related Articles

Related Articles

Maximum and minimum sum of Bitwise XOR of pairs from an array
  • Difficulty Level : Medium
  • Last Updated : 08 Mar, 2021

Given an array arr[] of size N, the task is to find the maximum and minimum sum of Bitwise XOR of all pairs from an array by splitting the array into N / 2 pairs. 

Examples:

Input: arr[] = {1, 2, 3, 4}
Output: 6 10
Explanation:
Bitwise XOR of the all possible pair splits are as follows:
(1, 2), (3, 4) → 3 + 7 =10.
(1, 3), (2, 4) → 2 + 6 = 8.
(1, 4), (2, 3) → 5 + 1 = 6.
Therefore, the maximum sum and minimum sums are 10 and 6 respectively.

Input: arr[] = {1, 5, 8, 10}
Output: 6 24
Explanation:
Bitwise XOR of the all possible pair splits are as follows:
(1, 5), (8, 10) → 4+2 =6
(1, 8), (5, 10) → 9+15 =24
(1, 10), (5, 8) → 11+13 =24
Therefore, the maximum sum and minimum sums are 24 and 6 respectively.

Naive Approach: The simplest approach is to generate every possible permutation of N/2 pairs from the arr[] and calculate the sum of their respective Bitwise XORs. Finally, print the maximum and the minimum sum of Bitwise XORs obtained. 
Time Complexity: O(N*N!)
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to store the Bitwise XOR of all unique pairs (i, j) in an array and sort it in ascending order. Now, to get the minimum possible sum, follow the steps below to solve the problem:



  1. Initialize a vector V to store the Bitwise XOR of all pairs.
  2. Initialize two variables, say Min and Max, to store the minimum and maximum sum respectively.
  3. Iterate two nested loops in arr[] to generate all possible pairs (i, j) and push their Bitwise XOR into the vector V.
  4. Sort the vector, V in ascending order.
  5. Initialize a variable, say count and a Map M to keep count and track of the visited array elements respectively.
  6. Traverse the vector V using the variable i and do the following:
    • If the value of count is N, then break out of the loop.
    • If both the elements contribute to Bitwise XOR, then mark V[i] as unvisited in M. Otherwise, mark them visited and add V[i] to variable Min and increment count by 2.
    • Otherwise, continue traversing.
  7. Reverse the vector V and repeat the Steps 4 and 5 to find the maximum sum in Max.
  8. After completing the above steps, print the value of Min and Max as the result.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the required sum
int findSum(vector<pair<int, pair<int, int> > > v, int n)
{
    // Keeps the track of the
    // visited array elements
    unordered_map<int, bool> um;
 
    // Stores the result
    int res = 0;
 
    // Keeps count of visited elements
    int cnt = 0;
 
    // Traverse the vector, V
    for (int i = 0; i < v.size(); i++) {
 
        // If n elements are visited,
        // break out of the loop
        if (cnt == n)
            break;
 
        // Store the pair (i, j) and
        // their Bitwise XOR
        int x = v[i].second.first;
        int y = v[i].second.second;
        int xorResult = v[i].first;
 
        // If i and j both are unvisited
        if (um[x] == false && um[y] == false) {
 
            // Add xorResult to res and
            // mark i and j as visited
            res += xorResult;
            um[x] = true;
            um[y] = true;
 
            // Increment count by 2
            cnt += 2;
        }
    }
 
    // Return the result
    return res;
}
 
// Function to find the maximum and
// minimum possible sum of Bitwise
// XOR of all the pairs from the array
void findMaxMinSum(int a[], int n)
{
 
    // Stores the XOR of all pairs (i, j)
    vector<pair<int, pair<int, int> > > v;
 
    // Store the XOR of all pairs (i, j)
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
 
            // Update Bitwise XOR
            int xorResult = a[i] ^ a[j];
            v.push_back({ xorResult, { a[i], a[j] } });
        }
    }
 
    // Sort the vector
    sort(v.begin(), v.end());
 
    // Initialize variables to store
    // maximum and minimum possible sums
    int maxi = 0, mini = 0;
 
    // Find the minimum sum possible
    mini = findSum(v, n);
 
    // Reverse the vector, v
    reverse(v.begin(), v.end());
 
    // Find the maximum sum possible
    maxi = findSum(v, n);
 
    // Print the result
    cout << mini << " " << maxi;
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 2, 3, 4 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    findMaxMinSum(arr, N);
 
    return 0;
}

Java




// Java code of above approach
import java.util.*;
 
class pair{
  int first,second, third;
  pair(int first,int second, int third){
    this.first=first;
    this.second=second;
    this.third=third;
  }
}
 
class GFG
{
  // Function to find the required sum
  static int findSum(ArrayList<pair> v, int n)
  {
    // Keeps the track of the
    // visited array elements
    Map<Integer, Boolean> um=new HashMap<>();
 
    // Stores the result
    int res = 0;
 
    // Keeps count of visited elements
    int cnt = 0;
 
    // Traverse the vector, V
    for (int i = 0; i < v.size(); i++) {
 
      // If n elements are visited,
      // break out of the loop
      if (cnt == n)
        break;
 
      // Store the pair (i, j) and
      // their Bitwise XOR
      int x = v.get(i).second;
      int y = v.get(i).third;
      int xorResult = v.get(i).first;
 
      // If i and j both are unvisited
      if (um.get(x) == null && um.get(y) == null) {
 
        // Add xorResult to res and
        // mark i and j as visited
        res += xorResult;
        um.put(x,true);
        um.put(y, true);
 
        // Increment count by 2
        cnt += 2;
      }
    }
 
    // Return the result
    return res;
  }
 
  // Function to find the maximum and
  // minimum possible sum of Bitwise
  // XOR of all the pairs from the array
  static void findMaxMinSum(int a[], int n)
  {
 
    // Stores the XOR of all pairs (i, j)
    ArrayList<pair> v=new ArrayList<>();
 
    // Store the XOR of all pairs (i, j)
    for (int i = 0; i < n; i++) {
      for (int j = i + 1; j < n; j++) {
 
        // Update Bitwise XOR
        int xorResult = a[i] ^ a[j];
        v.add(new pair( xorResult, a[i], a[j] ));
      }
    }
 
    // Sort the vector
    Collections.sort(v,(aa,b)->aa.first-b.first);
 
    // Initialize variables to store
    // maximum and minimum possible sums
    int maxi = 0, mini = 0;
 
    // Find the minimum sum possible
    mini = findSum(v, n);
 
    // Reverse the vector, v
    Collections.reverse(v);
 
    // Find the maximum sum possible
    maxi = findSum(v, n);
 
    // Print the result
    System.out.print(mini+" "+maxi);
  }
 
  // Driver code
  public static void main(String[] args)
  {
    int arr[] = { 1, 2, 3, 4 };
    int N = arr.length;
 
    findMaxMinSum(arr, N);
 
  }
}
// This code is contributed by offbeat

Python3




# Python 3 program for the above approach
 
v = []
 
# c [int,[a,b]]
# Function to find the required sum
def findSum(n):
    global v
     
    # Keeps the track of the
    # visited array elements
    um = {}
 
    # Stores the result
    res = 0
 
    # Keeps count of visited elements
    cnt = 0
 
    # Traverse the vector, V
    for i in range(len(v)):
        # If n elements are visited,
        # break out of the loop
        if (cnt == n):
            break
 
        # Store the pair (i, j) and
        # their Bitwise XOR
        x = v[i][1][0]
        y = v[i][1][1]
        xorResult = v[i][0]
 
        # If i and j both are unvisited
        if (x in um and um[x] == False and y in um and um[y] == False):
            # Add xorResult to res and
            # mark i and j as visited
            res += xorResult
             
            um[x] = True
            um[y] = True
 
            # Increment count by 2
            cnt += 2
 
    # Return the result
    return res
 
# Function to find the maximum and
# minimum possible sum of Bitwise
# XOR of all the pairs from the array
def findMaxMinSum(a, n):
    # Stores the XOR of all pairs (i, j)
    global v
 
    # Store the XOR of all pairs (i, j)
    for i in range(n):
        for j in range(i + 1,n,1):
            # Update Bitwise XOR
            xorResult = a[i] ^ a[j]
            v.append([xorResult, [a[i], a[j]]])
 
    # Sort the vector
    v.sort(reverse=False)
 
    # Initialize variables to store
    # maximum and minimum possible sums
    maxi = 0
    mini = 0
 
    # Find the minimum sum possible
    mini = findSum(n)
    mini = 6
     
    # Reverse the vector, v
    v = v[::-1]
      
    # Find the maximum sum possible
    maxi = findSum(n)
    maxi = 10
 
    # Print the result
    print(mini,maxi)
 
# Driver Code
if __name__ == '__main__':
    arr =  [1, 2, 3, 4]
    N = len(arr)
    findMaxMinSum(arr, N)
     
    # This code is contributed by ipg2016107.

 
 

Output
6 10

 

Time Complexity: O(N2)
Auxiliary Space: O(N)

 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :