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++14
// CPP implementation of the approach #include <bits/stdc++.h> 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 |
Javascript
<script> // Javascript implementation of above approach // Tree node class Node { constructor(data)
{
this .left = null ;
this .right = null ;
this .data = data;
}
} // Recursive function to update // the parent array such that parent[i] // stores the parent of i function updateParent(parent, 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 function getMaxXor(root, n, val, x)
{ // Create the parent array
let parent = new Array(n + 1);
parent.fill(0);
updateParent(parent, root);
// Initialize max with x XOR val
let 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 let n = 6; let 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);
let val = 6, x = 4; document.write(getMaxXor(root, n, val, x)); // This code is contributed by divyeshrabadiya07 </script> |
Output:
7
Time Complexity: O(N)