Count of subtrees in a Binary Tree having XOR value K
Last Updated :
29 Nov, 2023
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++
// 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>
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.
C++
#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();
OutputCount 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.
Similar Reads
Count of subtrees in a Binary Tree having bitwise OR value K Given a value K and a binary tree, the task is to find out the number of subtrees having bitwise OR of all its elements equal to K. Examples: Input: K = 5, Tree = 2 / \ 1 1 / \ \ 10 5 4 Output: 2 Explanation: Subtree 1: 5 It has only one element i.e. 5. So bitwise OR of subtree = 5 Subtree 2: 1 \ 4
8 min read
Convert given binary tree to a XOR tree Given a Binary Tree where each node has a value of either 0 or 1, the task is to convert the given Binary tree to an XOR tree i.e a tree such that each node value is the logical XOR between its children. Note: Leaf nodes and nodes with one child are not considered as they don't have both children. E
7 min read
Count of duplicate Subtrees in an N-ary Tree Given the root of an n-ary tree, the task is to find the number of subtrees that have duplicates in the n-ary tree. Two trees are duplicates if they have the same structure with the same node values. Examples: Input: 1 N 2 2 3 N 4 N 4 4 3 N N N N NOutput: 2Explanation: [4], [3] are duplicate subtree
6 min read
Count pairs in a binary tree whose sum is equal to a given value x Given a binary tree containing n distinct numbers and a value x. The problem is to count pairs in the given binary tree whose sum is equal to the given value x. Examples: Input : 5 / \ 3 7 / \ / \ 2 4 6 8 x = 10 Output : 3 The pairs are (3, 7), (2, 8) and (4, 6). 1) Naive Approach: One by one get ea
15+ min read
Count of Fibonacci paths in a Binary tree Given a Binary Tree, the task is to count the number of Fibonacci paths in the given Binary Tree. Fibonacci Path is a path which contains all nodes in root to leaf path are terms of Fibonacci series. Example: Input: 0 / \ 1 1 / \ / \ 1 10 70 1 / \ 81 2 Output: 2 Explanation: There are 2 Fibonacci pa
10 min read