Related Articles

Related Articles

Maximum XOR with given value in the path from root to given node in the tree
  • Last Updated : 24 Feb, 2020

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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);
  
    // Initialze 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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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);
  
        // Initialze 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));
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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)
  
    # Initialze 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
  
  

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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);
  
        // Initialze 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

chevron_right


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.




My Personal Notes arrow_drop_up