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 ``using` `namespace` `std;` `// Function to find the required sum``int` `findSum(vector > > 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 > > 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);` `    ``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 v, ``int` `n)``  ``{``    ``// Keeps the track of the``    ``// visited array elements``    ``Map 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 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