Skip to content
Related Articles
Maximum XOR with given value in the path from root to given node in the tree
• Last Updated : 02 Jun, 2021

Given a tree with N distinct nodes from the range [1, n] and two integers x and val. The task is to find the maximum value of any node when XORed with x on the path from the root to val.
Examples:

```Input: val = 6, x = 4
1
/ \
2   3
/     \
4       5
/
6
Output: 7
the path is 1 -> 3 -> 5 -> 6
1 ^ 4 = 5
3 ^ 4 = 7
5 ^ 4 = 1
6 ^ 4 = 2
Maximum is 7

Input: val = 4, x = 1
1
/ \
2   3
/
4
Output: 5```

Approach:

• An optimized solution to the problem is to create a parent array to store the parent of each of the node.
• Start from the given node and keep on going up in the tree using the parent array (this will be helpful when answering a number of queries as only the nodes on the path will be traversed). Take the xor with x of all the nodes in the path till root.
• The maximum xor calculated for the path is the answer.

Below is the implementation of the above approach:

## C++

 `// CPP implementation of the approach``#include ``using` `namespace` `std;` `// Tree node``class` `Node``{``public``:``    ``int` `data;``    ``Node *left, *right;` `    ``Node(``int` `data)``    ``{``        ``this``->data = data;``        ``this``->left = NULL;``        ``this``->right = NULL;``    ``}``};` `// Recursive function to update``// the parent array such that parent[i]``// stores the parent of i``void` `updateParent(``int` `*parent, Node *node)``{``    ``// If node is null then return``    ``if` `(node == NULL)``        ``return``;` `    ``// If left child of the node is not``    ``// null then set node as the parent``    ``// of its left child``    ``if` `(node->left != NULL)``        ``parent[node->left->data] = node->data;` `    ``// If right child of the node is not``    ``// null then set node as the parent``    ``// of its right child``    ``if` `(node->right != NULL)``        ``parent[node->right->data] = node->data;` `    ``// Recursive call for the``    ``// children of current node``    ``updateParent(parent, node->left);``    ``updateParent(parent, node->right);``}` `// Function to return the maximum value``// of a node on the path from root to val``// when Xored with x``int` `getMaxXor(Node *root, ``int` `n, ``int` `val, ``int` `x)``{``    ``// Create the parent array``    ``int` `*parent = ``new` `int``[n + 1];``    ``updateParent(parent, root);` `    ``// Initialize max with x XOR val``    ``int` `maximum = x ^ val;` `    ``// Get to the parent of val``    ``val = parent[val];` `    ``// 0 is the parent of the root``    ``while` `(val != 0)``    ``{``        ``// Update maximum``        ``maximum = max(maximum, x ^ val);` `        ``// Get one level up the tree``        ``val = parent[val];``    ``}``    ``return` `maximum;``}` `// Driver Code``int` `main()``{``    ``int` `n = 6;``    ``Node *root;``    ``root = ``new` `Node(1);``    ``root->left = ``new` `Node(2);``    ``root->right = ``new` `Node(3);``    ``root->left->left = ``new` `Node(4);``    ``root->right->right = ``new` `Node(5);``    ``root->right->right->left = ``new` `Node(6);` `    ``int` `val = 6, x = 4;``    ``cout << getMaxXor(root, n, val, x) << endl;` `    ``return` `0;``}` `// This code is contributed by``// sanjeev2552`

## Java

 `// Java implementation of the approach``public` `class` `GFG {` `    ``// Tree node``    ``static` `class` `Node {``        ``int` `data;``        ``Node left, right;``        ``Node(``int` `data)``        ``{``            ``this``.data = data;``            ``left = ``null``;``            ``right = ``null``;``        ``}``    ``}` `    ``// Recursive function to update``    ``// the parent array such that parent[i]``    ``// stores the parent of i``    ``static` `void` `updateParent(``int` `parent[],``                             ``Node node)``    ``{` `        ``// If node is null then return``        ``if` `(node == ``null``)``            ``return``;` `        ``// If left child of the node is not``        ``// null then set node as the parent``        ``// of its left child``        ``if` `(node.left != ``null``)``            ``parent[node.left.data] = node.data;` `        ``// If right child of the node is not``        ``// null then set node as the parent``        ``// of its right child``        ``if` `(node.right != ``null``)``            ``parent[node.right.data] = node.data;` `        ``// Recursive call for the``        ``// children of current node``        ``updateParent(parent, node.left);``        ``updateParent(parent, node.right);``    ``}` `    ``// Function to return the maximum value``    ``// of a node on the path from root to val``    ``// when Xored with x``    ``static` `int` `getMaxXor(Node root,``                         ``int` `n, ``int` `val, ``int` `x)``    ``{` `        ``// Create the parent array``        ``int` `parent[] = ``new` `int``[n + ``1``];``        ``updateParent(parent, root);` `        ``// Initialize max with x XOR val``        ``int` `max = x ^ val;` `        ``// Get to the parent of val``        ``val = parent[val];` `        ``// 0 is the parent of the root``        ``while` `(val != ``0``) {` `            ``// Update maximum``            ``max = Math.max(max, x ^ val);` `            ``// Get one level up the tree``            ``val = parent[val];``        ``}``        ``return` `max;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``6``;``        ``Node root = ``new` `Node(``1``);``        ``root.left = ``new` `Node(``2``);``        ``root.right = ``new` `Node(``3``);``        ``root.left.left = ``new` `Node(``4``);``        ``root.right.right = ``new` `Node(``5``);``        ``root.right.right.left = ``new` `Node(``6``);` `        ``int` `val = ``6``, x = ``4``;``        ``System.out.println(getMaxXor(root, n, val, x));``    ``}``}`

## Python3

 `# Python3 implementation of the approach` `# Tree node``class` `Node:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None``    ` `# Recursive function to update``# the parent array such that parent[i]``# stores the parent of i``def` `updateParent(parent, node):` `    ``# If node is None then return``    ``if` `(node ``=``=` `None``):``        ``return` `parent` `    ``# If left child of the node is not``    ``# None then set node as the parent``    ``# of its left child``    ``if` `(node.left !``=` `None``):``        ``parent[node.left.data] ``=` `node.data` `    ``# If right child of the node is not``    ``# None then set node as the parent``    ``# of its right child``    ``if` `(node.right !``=` `None``):``        ``parent[node.right.data] ``=` `node.data` `    ``# Recursive call for the``    ``# children of current node``    ``parent ``=` `updateParent(parent, node.left)``    ``parent ``=` `updateParent(parent, node.right)``    ``return` `parent` `# Function to return the maximum value``# of a node on the path from root to val``# when Xored with x``def` `getMaxXor(root, n, val, x):` `    ``# Create the parent array``    ``parent ``=` `[``0``]``*``(n ``+` `1``)``    ``parent``=``updateParent(parent, root)` `    ``# Initialize max with x XOR val``    ``maximum ``=` `x ^ val` `    ``# Get to the parent of val``    ``val ``=` `parent[val]` `    ``# 0 is the parent of the root``    ``while` `(val !``=` `0``):``    ` `        ``# Update maximum``        ``maximum ``=` `max``(maximum, x ^ val)` `        ``# Get one level up the tree``        ``val ``=` `parent[val]``    ` `    ``return` `maximum` `# Driver Code``n ``=` `6` `root ``=` `Node(``1``)``root.left ``=` `Node(``2``)``root.right ``=` `Node(``3``)``root.left.left ``=` `Node(``4``)``root.right.right ``=` `Node(``5``)``root.right.right.left ``=` `Node(``6``)` `val ``=` `6``x ``=` `4``print``( getMaxXor(root, n, val, x) )` `# This code is contributed by Arnab Kundu`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{` `    ``// Tree node``    ``public` `class` `Node``    ``{``        ``public` `int` `data;``        ``public` `Node left, right;``        ``public` `Node(``int` `data)``        ``{``            ``this``.data = data;``            ``left = ``null``;``            ``right = ``null``;``        ``}``    ``}` `    ``// Recursive function to update``    ``// the parent array such that parent[i]``    ``// stores the parent of i``    ``static` `void` `updateParent(``int` `[]parent,``                             ``Node node)``    ``{` `        ``// If node is null then return``        ``if` `(node == ``null``)``            ``return``;` `        ``// If left child of the node is not``        ``// null then set node as the parent``        ``// of its left child``        ``if` `(node.left != ``null``)``            ``parent[node.left.data] = node.data;` `        ``// If right child of the node is not``        ``// null then set node as the parent``        ``// of its right child``        ``if` `(node.right != ``null``)``            ``parent[node.right.data] = node.data;` `        ``// Recursive call for the``        ``// children of current node``        ``updateParent(parent, node.left);``        ``updateParent(parent, node.right);``    ``}` `    ``// Function to return the maximum value``    ``// of a node on the path from root to val``    ``// when Xored with x``    ``static` `int` `getMaxXor(Node root, ``int` `n,``                         ``int` `val, ``int` `x)``    ``{` `        ``// Create the parent array``        ``int` `[]parent = ``new` `int``[n + 1];``        ``updateParent(parent, root);` `        ``// Initialize max with x XOR val``        ``int` `max = x ^ val;` `        ``// Get to the parent of val``        ``val = parent[val];` `        ``// 0 is the parent of the root``        ``while` `(val != 0)``        ``{` `            ``// Update maximum``            ``max = Math.Max(max, x ^ val);` `            ``// Get one level up the tree``            ``val = parent[val];``        ``}``        ``return` `max;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int` `n = 6;``        ``Node root = ``new` `Node(1);``        ``root.left = ``new` `Node(2);``        ``root.right = ``new` `Node(3);``        ``root.left.left = ``new` `Node(4);``        ``root.right.right = ``new` `Node(5);``        ``root.right.right.left = ``new` `Node(6);` `        ``int` `val = 6, x = 4;``        ``Console.WriteLine(getMaxXor(root, n, val, x));``    ``}``}` `// This code is contributed by Princi Singh`
Output:

`7`

Time Complexity: O(N)

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 industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up