# Maximum Bitwise XOR of node values of an Acyclic Graph made up of N given vertices using M edges

• Last Updated : 10 Jun, 2021

Given N nodes valued by [1, N], an array arr[] consisting of N positive integers such that the ith node ( 1-based indexing ) has the value arr[i] and an integer M, the task is to find the maximum Bitwise XOR of node values of an acyclic graph formed by M edges.

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[]= {1, 2, 3, 4}, M = 2
Output: 7
Explanation:
Acyclic graphs having M(= 2) edges can be formed by vertices as:

1. {1, 2, 3}: The value of the Bitwise XOR of vertices is 1^2^3 = 0.
2. {2, 3, 4}: The value of the Bitwise XOR of vertices is 2^3^4 = 5.
3. {1, 2, 4}: The value of the Bitwise XOR of vertices is 1^2^4 = 7.
4. {1, 4, 3}: The value of the Bitwise XOR of vertices is 1^4^3 = 6.

Therefore, the maximum Bitwise XOR among all possible acyclic graphs is 7.

Input: arr[] = {2, 4, 8, 16}, M = 2
Output: 28

Approach: The given problem can be solved by using the fact that an acyclic graph having M edges must have (M + 1) vertices. Therefore, the task is reduced to finding the maximum Bitwise XOR of a subset of the array arr[] having (M + 1) vertices. Follow the steps below to solve the problem:

• Initialize a variable, say maxAns as 0 that stores the maximum Bitwise XOR of an acyclic graph having M edges.
• Generate all possible subsets of the array arr[] and for each subset find the Bitwise XOR of the elements of the subset and update the value of maxAns to the maximum of maxAns and Bitwise XOR.
• After completing the above steps, print the value of maxAns 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 maximum Bitwise``// XOR of any subset of the array of size K``int` `maximumXOR(``int` `arr[], ``int` `n, ``int` `K)``{``    ``// Number of node must K + 1 for``    ``// K edges``    ``K++;` `    ``// Stores the maximum Bitwise XOR``    ``int` `maxXor = INT_MIN;` `    ``// Generate all subsets of the array``    ``for` `(``int` `i = 0; i < (1 << n); i++) {` `        ``// __builtin_popcount() returns``        ``// the number of sets bits in``        ``// an integer``        ``if` `(__builtin_popcount(i) == K) {` `            ``// Initialize current xor as 0``            ``int` `cur_xor = 0;` `            ``for` `(``int` `j = 0; j < n; j++) {` `                ``// If jth bit is set in i``                ``// then include jth element``                ``// in the current xor``                ``if` `(i & (1 << j))``                    ``cur_xor = cur_xor ^ arr[j];``            ``}` `            ``// Update the maximum Bitwise``            ``// XOR obtained so far``            ``maxXor = max(maxXor, cur_xor);``        ``}``    ``}` `    ``// Return the maximum XOR``    ``return` `maxXor;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 2, 3, 4 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(``int``);``    ``int` `M = 2;``    ``cout << maximumXOR(arr, N, M);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `class` `GFG{` `// Function to find the maximum Bitwise``// XOR of any subset of the array of size K``static` `int` `maximumXOR(``int` `arr[], ``int` `n, ``int` `K)``{``    ` `    ``// Number of node must K + 1 for``    ``// K edges``    ``K++;` `    ``// Stores the maximum Bitwise XOR``    ``int` `maxXor = Integer.MIN_VALUE;` `    ``// Generate all subsets of the array``    ``for``(``int` `i = ``0``; i < (``1` `<< n); i++)``    ``{``        ` `        ``// Integer.bitCount() returns``        ``// the number of sets bits in``        ``// an integer``        ``if` `(Integer.bitCount(i) == K)``        ``{``            ` `            ``// Initialize current xor as 0``            ``int` `cur_xor = ``0``;` `            ``for``(``int` `j = ``0``; j < n; j++)``            ``{``                ` `                ``// If jth bit is set in i``                ``// then include jth element``                ``// in the current xor``                ``if` `((i & (``1` `<< j)) != ``0``)``                    ``cur_xor = cur_xor ^ arr[j];``            ``}` `            ``// Update the maximum Bitwise``            ``// XOR obtained so far``            ``maxXor = Math.max(maxXor, cur_xor);``        ``}``    ``}` `    ``// Return the maximum XOR``    ``return` `maxXor;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``1``, ``2``, ``3``, ``4` `};``    ``int` `N = arr.length;``    ``int` `M = ``2``;``    ` `    ``System.out.println(maximumXOR(arr, N, M));``}``}` `// This code is contributed by Kingash`

## Python3

 `# Python3 program for the above approach` `# Function to find the maximum Bitwise``# XOR of any subset of the array of size K``def` `maximumXOR(arr, n, K):``  ` `    ``# Number of node must K + 1 for``    ``# K edges``    ``K ``+``=` `1` `    ``# Stores the maximum Bitwise XOR``    ``maxXor ``=` `-``10``*``*``9` `    ``# Generate all subsets of the array``    ``for` `i ``in` `range``(``1``<

## C#

 `// C# program for the above approach``using` `System;``using` `System.Linq;` `class` `GFG{` `// Function to find the maximum Bitwise``// XOR of any subset of the array of size K``static` `int` `maximumXOR(``int` `[]arr, ``int` `n, ``int` `K)``{``    ` `    ``// Number of node must K + 1 for``    ``// K edges``    ``K++;` `    ``// Stores the maximum Bitwise XOR``    ``int` `maxXor = Int32.MinValue;` `    ``// Generate all subsets of the array``    ``for``(``int` `i = 0; i < (1 << n); i++)``    ``{``        ` `        ``// Finding number of sets``        ``// bits in an integer``        ``if` `(Convert.ToString(i, 2).Count(c => c == ``'1'``) == K)``        ``{``            ` `            ``// Initialize current xor as 0``            ``int` `cur_xor = 0;` `            ``for``(``int` `j = 0; j < n; j++)``            ``{``                ` `                ``// If jth bit is set in i``                ``// then include jth element``                ``// in the current xor``                ``if` `((i & (1 << j)) != 0)``                    ``cur_xor = cur_xor ^ arr[j];``            ``}` `            ``// Update the maximum Bitwise``            ``// XOR obtained so far``            ``maxXor = Math.Max(maxXor, cur_xor);``        ``}``    ``}` `    ``// Return the maximum XOR``    ``return` `maxXor;``}` `// Driver code``static` `void` `Main()``{``    ``int` `[] arr = { 1, 2, 3, 4 };``    ``int` `N = arr.Length;``    ``int` `M = 2;``    ` `    ``Console.WriteLine(maximumXOR(arr, N, M));``}``}` `// This code is contributed by jana_sayantan.`

## Javascript

 ``
Output:
`7`

Time Complexity: O(N * 2N
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up