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 nodestruct Node {    int data;    struct Node *left, *right;}; // A utility function to// allocate a new nodestruct Node* newNode(int data){    struct Node* newNode = new Node;    newNode->data = data;    newNode->left        = newNode->right = NULL;    return (newNode);} // Recursive Function to compute the countint 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 countint 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 programint 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 Kimport 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 nodeclass Node:         def __init__(self, data):                 self.data = data        self.left = None        self.right = None   # A utility function to# allocate a new nodedef newNode(data):         temp = Node(data)    return temp   # Recursive Function to compute the countdef 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 countdef 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 programif __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 Kusing System; class GFG{ // A binary tree nodeclass Node{    public int data;    public Node left, right;}; static int res;static int k; // A utility function to// allocate a new nodestatic 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 countstatic 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 codepublic 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