Given a value K and a binary tree, the task is to find out number of subtrees having XOR of all its elements equal to K.
Examples:
Input K = 5, Tree =
2
/ \
1 9
/ \
10 5
Output: 2
Explanation:
Subtree 1:
5
It has only one element i.e. 5.
So XOR of subtree = 5
Subtree 1:
2
/ \
1 9
/ \
10 5
It has elements 2, 1, 9, 10, 5.
So XOR of subtree = 2 ^ 1 ^ 9 ^ 10 ^ 5 = 5
Input K = 3, Tree =
4
/ \
3 9
/ \
2 2
Output: 1
Explanation
Subtree:
3
/ \
2 2
It has elements 3, 2, 2.
So XOR of subtree = 3 ^ 2 ^ 2 = 3
Approach :
- Traverse the tree recursively using pre-order traversal.
-
For each node keep calculating the XOR of its subtree as:
XOR of its subtree = (XOR of node’s left subtree) ^ (XOR of nodes’s right subtree) ^ (node’s value)
- If the XOR of any subtree is K, increment the counter variable.
- Print the value in counter as the required count
Below is the implementation of the above approach:
// C++ program to find the count of // subtrees in a Binary Tree // having XOR value K #include <bits/stdc++.h> using namespace std;
// A binary tree node struct Node {
int data;
struct Node *left, *right;
}; // A utility function to // allocate a new node struct Node* newNode( int data)
{ struct Node* newNode = new Node;
newNode->data = data;
newNode->left
= newNode->right = NULL;
return (newNode);
} int rec(Node* root, int & res, int & k)
{ // Base Case:
// If node is NULL, return 0
if (root == NULL) {
return 0;
}
// Calculating the XOR
// of the current subtree
int xr = root->data;
xr ^= rec(root->left, res, k);
xr ^= rec(root->right, res, k);
// Increment res
// if xr is equal to k
if (xr == k) {
res++;
}
// Return the XOR value
// of the current subtree
return xr;
} // Function to find the required count int findCount(Node* root, int K)
{ // Initialize result variable 'res'
int res = 0;
// Recursively traverse the tree
// and compute the count
rec(root, res, K);
// return the count 'res'
return res;
} // Driver program int main( void )
{ /*
2
/ \
1 9
/ \
10 5
*/
// Create the binary tree
// by adding nodes to it
struct Node* root = newNode(2);
root->left = newNode(1);
root->right = newNode(9);
root->left->left = newNode(10);
root->left->right = newNode(5);
int K = 5;
cout << findCount(root, K);
return 0;
} |
// Java program to find the count of // subtrees in a Binary Tree // having XOR value K import java.util.*;
class GFG{
// A binary tree node
static class Node
{
int data;
Node left,right;
};
static int res;
static int k;
// A utility function to
// allocate a new node
static Node newNode( int data)
{
Node newNode = new Node();
newNode.data = data;
newNode.left= null ;
newNode.right = null ;
return newNode;
}
static int rec(Node root)
{
// Base Case:
// If node is null, return 0
if (root == null ) {
return 0 ;
}
// Calculating the XOR
// of the current subtree
int xr = (root.data); //^rec(root.left)^rec(root.right);
xr ^= rec(root.left);
xr ^= rec(root.right);
// Increment res
// if xr is equal to k
if (xr == k) {
res++;
}
// Return the XOR value
// of the current subtree
return xr;
}
// Function to find the required count
static int findCount(Node root, int K)
{
// Initialize result variable 'res'
res = 0 ;
k = K;
// Recursively traverse the tree
// and compute the count
rec(root);
// return the count 'res'
return res;
}
// Driver program
public static void main(String args[])
{
/*
2
/ \
1 9
/ \
10 5
*/
// Create the binary tree
// by adding nodes to it
Node root = newNode( 2 );
root.left = newNode( 1 );
root.right = newNode( 9 );
root.left.left =newNode( 10 );
root.left.right = newNode( 5 );
int K = 5 ;
System.out.println(findCount(root, K));
}
} // This code is contributed by AbhiThakur |
# Python3 program to find the count of # subtrees in a Binary Tree # having XOR value K # A binary tree node class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
# A utility function to # allocate a new node def newNode(data):
newNode = Node(data)
return newNode
def rec(root, res, k):
# Base Case:
# If node is None, return 0
if (root = = None ):
return [ 0 , res];
# Calculating the XOR
# of the current subtree
xr = root.data;
tmp,res = rec(root.left, res, k);
xr^ = tmp
tmp,res = rec(root.right, res, k);
xr^ = tmp
# Increment res
# if xr is equal to k
if (xr = = k):
res + = 1
# Return the XOR value
# of the current subtree
return xr, res;
# Function to find the required count def findCount(root, K):
# Initialize result variable 'res'
res = 0 ;
# Recursively traverse the tree
# and compute the count
tmp,res = rec(root, res, K);
# return the count 'res'
return res;
# Driver program if __name__ = = '__main__' :
'''
2
/ \
1 9
/ \
10 5
'''
# Create the binary tree
# by adding nodes to it
root = newNode( 2 );
root.left = newNode( 1 );
root.right = newNode( 9 );
root.left.left = newNode( 10 );
root.left.right = newNode( 5 );
K = 5 ;
print (findCount(root, K))
# This code is contributed by rutvik_56 |
// C# program to find the count of // subtrees in a Binary Tree // having XOR value K using System;
public class GFG{
// A binary tree node
class Node
{
public int data;
public Node left,right;
};
static int res;
static int k;
// A utility function to
// allocate a new node
static Node newNode( int data)
{
Node newNode = new Node();
newNode.data = data;
newNode.left= null ;
newNode.right = null ;
return newNode;
}
static int rec(Node root)
{
// Base Case:
// If node is null, return 0
if (root == null ) {
return 0;
}
// Calculating the XOR
// of the current subtree
int xr = (root.data); //^rec(root.left)^rec(root.right);
xr ^= rec(root.left);
xr ^= rec(root.right);
// Increment res
// if xr is equal to k
if (xr == k) {
res++;
}
// Return the XOR value
// of the current subtree
return xr;
}
// Function to find the required count
static int findCount(Node root, int K)
{
// Initialize result variable 'res'
res = 0;
k = K;
// Recursively traverse the tree
// and compute the count
rec(root);
// return the count 'res'
return res;
}
// Driver program
public static void Main(String []args)
{
/*
2
/ \
1 9
/ \
10 5
*/
// Create the binary tree
// by adding nodes to it
Node root = newNode(2);
root.left = newNode(1);
root.right = newNode(9);
root.left.left =newNode(10);
root.left.right = newNode(5);
int K = 5;
Console.WriteLine(findCount(root, K));
}
} // This code is contributed by sapnasingh4991 |
<script> // JavaScript program to find the count of // subtrees in a Binary Tree // having XOR value K // A binary tree node class Node { constructor()
{
this .data = 0;
this .left = null ;
this .right = null ;
}
}; var res = 0;
var k = 0;
// A utility function to // allocate a new node function newNode(data)
{ var newNode = new Node();
newNode.data = data;
newNode.left= null ;
newNode.right = null ;
return newNode;
} function rec(root)
{ // Base Case:
// If node is null, return 0
if (root == null ) {
return 0;
}
// Calculating the XOR
// of the current subtree
var xr = (root.data); //^rec(root.left)^rec(root.right);
xr ^= rec(root.left);
xr ^= rec(root.right);
// Increment res
// if xr is equal to k
if (xr == k) {
res++;
}
// Return the XOR value
// of the current subtree
return xr;
} // Function to find the required count function findCount(root, K)
{ // Initialize result variable 'res'
res = 0;
k = K;
// Recursively traverse the tree
// and compute the count
rec(root);
// return the count 'res'
return res;
} // Driver program /* 2
/ \ 1 9 / \ 10 5 */ // Create the binary tree // by adding nodes to it var root = newNode(2);
root.left = newNode(1); root.right = newNode(9); root.left.left =newNode(10); root.left.right = newNode(5); var K = 5;
document.write(findCount(root, K)); </script> |
2
Performance Analysis:
Time Complexity: As in the above approach, we are iterating over each node only once, therefore it will take O(N) time where N is the number of nodes in the Binary tree.
Auxiliary Space Complexity: As in the above approach there is no extra space used, therefore the Auxiliary Space complexity will be O(1).
Approach :
Approach to finding the count of subtrees in a binary tree with XOR value K:
- Create a hash table to store the XOR value of all the nodes encountered so far in the traversal, along with their frequency.
- Perform a pre-order traversal of the binary tree.
- At each node, compute the XOR value of the subtree rooted at that node.
- If the XOR value is equal to K, increment the count.
- Look up the hash table for the frequency of (XOR value – K). Add this frequency to the count.
- Add the XOR value of the current node to the hash table.
- Return the count.
#include <bits/stdc++.h> using namespace std;
// A binary tree node struct Node {
int data;
struct Node *left, *right;
}; // A utility function to // allocate a new node struct Node* newNode( int data)
{ struct Node* newNode = new Node;
newNode->data = data;
newNode->left
= newNode->right = NULL;
return (newNode);
} int rec(Node* root, int & res, int & k)
{ // Base Case:
// If node is NULL, return 0
if (root == NULL) {
return 0;
}
// Calculating the XOR
// of the current subtree
int xr = root->data;
xr ^= rec(root->left, res, k);
xr ^= rec(root->right, res, k);
// Increment res
// if xr is equal to k
if (xr == k) {
res++;
}
// Return the XOR value
// of the current subtree
return xr;
} // Function to find the required count int findCount(Node* root, int K)
{ // Initialize result variable 'res'
int res = 0;
// Recursively traverse the tree
// and compute the count
rec(root, res, K);
// return the count 'res'
return res;
} // Driver program int main( void )
{ /*
2
/ \
1 9
/ \
10 5
*/
// Create the binary tree
// by adding nodes to it
struct Node* root = newNode(2);
root->left = newNode(1);
root->right = newNode(9);
root->left->left = newNode(10);
root->left->right = newNode(5);
int K = 5;
cout << "Count of subtrees having XOR value " << K << " is " << findCount(root, K) << endl;
return 0;
} |
import java.util.*;
// A binary tree node class Node {
int data;
Node left, right;
// Constructor to create a new node
Node( int item) {
data = item;
left = right = null ;
}
} public class SubtreeXORCount {
// Utility function to calculate the count of subtrees with XOR value 'k'
public static int findCount(Node root, int k) {
int [] res = { 0 }; // Initialize the result variable 'res'
// Call the recursive helper function
rec(root, res, k);
// Return the count 'res'
return res[ 0 ];
}
// Recursive helper function to calculate XOR and count of subtrees
public static int rec(Node root, int [] res, int k) {
// Base Case: If the node is null, return 0
if (root == null ) {
return 0 ;
}
// Calculate the XOR of the current subtree
int xr = root.data;
xr ^= rec(root.left, res, k);
xr ^= rec(root.right, res, k);
// Increment 'res' if 'xr' is equal to 'k'
if (xr == k) {
res[ 0 ]++;
}
// Return the XOR value of the current subtree
return xr;
}
// Driver program
public static void main(String[] args) {
/*
2
/ \
1 9
/ \
10 5
*/
// Create the binary tree by adding nodes to it
Node root = new Node( 2 );
root.left = new Node( 1 );
root.right = new Node( 9 );
root.left.left = new Node( 10 );
root.left.right = new Node( 5 );
int K = 5 ;
System.out.println( "Count of subtrees having XOR value " + K + " is " + findCount(root, K));
}
} |
# A binary tree node class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
def rec(root, res, k):
# Base Case:
# If node is None, return 0
if root is None :
return 0
# Calculating the XOR
# of the current subtree
xr = root.data
xr ^ = rec(root.left, res, k)
xr ^ = rec(root.right, res, k)
# Increment res
# if xr is equal to k
if xr = = k:
res[ 0 ] + = 1
# Return the XOR value
# of the current subtree
return xr
# Function to find the required count def findCount(root, K):
# Initialize result variable 'res'
res = [ 0 ]
# Recursively traverse the tree
# and compute the count
rec(root, res, K)
# Return the count 'res'
return res[ 0 ]
# Driver program if __name__ = = "__main__" :
"""
2
/ \
1 9
/ \
10 5
"""
# Create the binary tree
# by adding nodes to it
root = Node( 2 )
root.left = Node( 1 )
root.right = Node( 9 )
root.left.left = Node( 10 )
root.left.right = Node( 5 )
K = 5
print ( "Count of subtrees having XOR value" , K, "is" , findCount(root, K))
|
using System;
// A binary tree node public class Node
{ public int data;
public Node left, right;
public Node( int data)
{
this .data = data;
this .left = this .right = null ;
}
} public class BinaryTree
{ // A utility function to calculate the count of subtrees
// with XOR value equal to K
public static int FindCount(Node root, int K)
{
int res = 0; // Initialize the result variable 'res'
Rec(root, ref res, K); // Recursively traverse the tree and compute the count
return res; // Return the count 'res'
}
private static int Rec(Node root, ref int res, int K)
{
// Base Case: If node is NULL, return 0
if (root == null )
{
return 0;
}
// Calculate the XOR of the current subtree
int xr = root.data;
xr ^= Rec(root.left, ref res, K);
xr ^= Rec(root.right, ref res, K);
// Increment res if xr is equal to K
if (xr == K)
{
res++;
}
// Return the XOR value of the current subtree
return xr;
}
// Driver program
public static void Main()
{
/*
2
/ \
1 9
/ \
10 5
*/
// Create the binary tree by adding nodes to it
Node root = new Node(2);
root.left = new Node(1);
root.right = new Node(9);
root.left.left = new Node(10);
root.left.right = new Node(5);
int K = 5;
Console.WriteLine( "Count of subtrees having XOR value " + K + " is " + FindCount(root, K));
}
} |
// A binary tree node class Node { constructor(item) {
this .data = item;
this .left = null ;
this .right = null ;
}
} class SubtreeXORCount { // Utility function to calculate the count of subtrees with XOR value 'k'
static findCount(root, k) {
let res = [0]; // Initialize the result variable 'res'
// Call the recursive helper function
SubtreeXORCount.rec(root, res, k);
// Return the count 'res'
return res[0];
}
// Recursive helper function to calculate XOR and count of subtrees
static rec(root, res, k) {
// Base Case: If the node is null, return 0
if (root === null ) {
return 0;
}
// Calculate the XOR of the current subtree
let xr = root.data;
xr ^= SubtreeXORCount.rec(root.left, res, k);
xr ^= SubtreeXORCount.rec(root.right, res, k);
// Increment 'res' if 'xr' is equal to 'k'
if (xr === k) {
res[0]++;
}
// Return the XOR value of the current subtree
return xr;
}
// Driver program
static main() {
/*
2
/ \
1 9
/ \
10 5
*/
// Create the binary tree by adding nodes to it
let root = new Node(2);
root.left = new Node(1);
root.right = new Node(9);
root.left.left = new Node(10);
root.left.right = new Node(5);
let K = 5;
console.log( "Count of subtrees having XOR value " + K + " is " + SubtreeXORCount.findCount(root, K));
}
} SubtreeXORCount.main(); |
Count of subtrees having XOR value 5 is 2
Performance Analysis:
Time complexity: O(n^2) in the worst case, where n is the number of nodes in the binary tree.
Space complexity: O(h), where h is the height of the binary tree.