 Open in App
Not now

# Count of subtrees in a Binary Tree having bitwise OR value K

• Last Updated : 15 Jun, 2021

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
it has 2 elements and bitwise OR of them is also 5

Input: K = 3, Tree =   4
/ \
3   9
/ \
2   2

Output:  1```

Approach:

• Traverse the tree recursively using pre-order traversal.
• For each node keep calculating the bitwise OR of its subtree as:

bitwise OR of its subtree = (bitwise OR of node’s left subtree) | (bitwise OR of node’s right subtree) | (node’s value)

• If the bitwise OR of any subtree is K, increment the counter variable.
• Print the value in the counter as the required count.

## C++

 `// C++ program to find the count of``// subtrees in a Binary Tree``// having bitwise OR value K` `#include ``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);``}` `// Recursive Function to compute the count``int` `rec(Node* root, ``int``& res, ``int``& k)``{``    ``// Base Case:``    ``// If node is NULL, return 0``    ``if` `(root == NULL) {``        ``return` `0;``    ``}` `    ``// Calculating the bitwise OR``    ``// of the current subtree``    ``int` `orr = root->data;``    ``orr |= rec(root->left, res, k);``    ``orr |= rec(root->right, res, k);` `    ``// Increment res``    ``// if xr is equal to k``    ``if` `(orr == k) {``        ``res++;``    ``}` `    ``// Return the bitwise OR value``    ``// of the current subtree``    ``return` `orr;``}` `// 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   1``    ``/ \   \``   ``10  5   4``    ``*/` `    ``// Create the binary tree``    ``// by adding nodes to it``    ``struct` `Node* root = newNode(2);``    ``root->left = newNode(1);``    ``root->right = newNode(1);``    ``root->right->right = newNode(4);``    ``root->left->left = newNode(10);``    ``root->left->right = newNode(5);` `    ``int` `K = 5;` `    ``cout << FindCount(root, K);``    ``return` `0;``}`

## Java

 `// Java program to find the count of``// subtrees in a Binary Tree``// having bitwise OR value K``import` `java.io.*;``class` `GFG``{``  ` `    ``// A binary tree node``    ``static` `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);``        ``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 code``    ``public` `static` `void` `main (String[] args)``    ``{``        ``/*``         ``2``        ``/ \``       ``1   1``      ``/ \   \``    ``10   5   4``    ``*/``        ` `        ``// Create the binary tree``        ``// by adding nodes to it``        ``Node root = newNode(``2``);``        ``root.left = newNode(``1``);``        ``root.right = newNode(``1``);``        ``root.right.right = newNode(``4``);``        ``root.left.left =newNode(``10``);``        ``root.left.right = newNode(``5``);``        ``int` `K = ``5``;``        ``System.out.println(findCount(root, K));``    ``}``}` `// This code is contributed by avanitrachhadiya2155`

## Python3

 `# Python3 program to find the count of``# subtrees in a Binary Tree``# having bitwise OR 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):``    ` `    ``temp ``=` `Node(data)``    ``return` `temp``  ` `# Recursive Function to compute the count``def` `rec(root, res, k):` `    ``# Base Case:``    ``# If node is NULL, return 0``    ``if` `(root ``=``=` `None``):``        ``return` `[``0``, res];``  ` `    ``# Calculating the bitwise OR``    ``# of the current subtree``    ``orr ``=` `root.data;``    ``tmp, res ``=` `rec(root.left, res, k);``    ``orr |``=` `tmp``    ``tmp, res ``=` `rec(root.right, res, k);``    ``orr |``=` `tmp``  ` `    ``# Increment res``    ``# if xr is equal to k``    ``if` `(orr ``=``=` `k):``        ``res ``+``=` `1``  ` `    ``# Return the bitwise OR value``    ``# of the current subtree``    ``return` `orr, 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   1``    ``/ \   \``   ``10  5   4``    ``'''``  ` `    ``# Create the binary tree``    ``# by adding nodes to it``    ``root ``=` `newNode(``2``);``    ``root.left ``=` `newNode(``1``);``    ``root.right ``=` `newNode(``1``);``    ``root.right.right ``=` `newNode(``4``);``    ``root.left.left ``=` `newNode(``10``);``    ``root.left.right ``=` `newNode(``5``);``  ` `    ``K ``=` `5``;``  ` `    ``print``(FindCount(root, K))``  ` `# This code is contributed by rutvik_56`

## C#

 `// C# program to find the count of``// subtrees in a Binary Tree``// having bitwise OR value K``using` `System;` `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);``    ``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 code``public` `static` `void` `Main(String []args)``{``    ` `    ``/*``         ``2``        ``/ \``       ``1   1``      ``/ \   \``    ``10   5   4``    ``*/` `    ``// Create the binary tree``    ``// by adding nodes to it``    ``Node root = newNode(2);``    ``root.left = newNode(1);``    ``root.right = newNode(1);``    ``root.right.right = newNode(4);``    ``root.left.left =newNode(10);``    ``root.left.right = newNode(5);` `    ``int` `K = 5;` `    ``Console.WriteLine(findCount(root, K));``}``}` `// This code is contributed by mohit kumar`

## Javascript

 ``

Output:

`2`

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).

My Personal Notes arrow_drop_up