# Count levels in a Binary Tree consisting of node values having set bits at different positions

• Difficulty Level : Hard
• Last Updated : 28 Jun, 2021

Given a Binary Tree consisting of N nodes, the task is to count the number of levels in a Binary Tree such that the set bits of all the node values at the same level is at different positions.

Examples:

Input:

```
5
/ \
6   9
/ \   \
1   4   7```

Output:
Explanation:
Level 1 has only 5 (= (101)2).
Level 2 has 6 (= (0110)2) and 9 (= (1001)2). All set bits are at unique positions.
Level 3 has 1 (0001)2, 4 (0100)2 and 7(0111)2. Therefore, 0th bit of node values 5 and 7 are set.

Input:

```
1
/ \
2   3
/ \   \
5   4   7```

Output: 1

Naive Approach: The simplest approach to solve this problem to traverse the binary tree using level order traversal and at each level of the tree store the set bits of all the nodes using Map. Traverse the map and check if the frequency of set-bit at the same position is less than or equal to 1 or not. If found to be true, then increment the count. Finally, print the count obtained.

Time Complexity: O(N)
Auxiliary Space: O(32)

Efficient Approach: The above approach can be optimized based on the following observations:

If all the set bits of two numbers A and B are at different positions
A XOR B = A OR B

Follow the steps below to solve the problem:

• Initialize a variable, say prefiX_XOR, to store the prefix XOR of all the nodes at each level.
• Initialize a variable, say prefiX_OR, to store the prefix OR of all the nodes at each level.
• Traverse the binary tree using level order traversal. At every ith level, check if prefix_XOR ^ nodes is equal to (prefix_OR | nodes) or not. If found to be true for all the nodes at current level, then increment the count.
• Finally, print the count obtained.

Below is the implementation of the above approach:

## C++14

 `// C++ program for the above approach` `#include `   `using` `namespace` `std;`   `// Structure of a node in` `// the binary tree` `struct` `TreeNode` `{` `  ``int` `val = 0;` `  ``TreeNode *left,*right;` `  ``TreeNode(``int` `x)` `  ``{` `        ``val = x;` `        ``left = NULL;` `        ``right = NULL;` `  ``}` `};`   `// Function to find total unique levels` `void` `uniqueLevels(TreeNode *root)` `{`   `    ``// Stores count of levels, where the set` `    ``// bits of all the nodes are at` `    ``// different positions` `    ``int` `uniqueLevels = 0;`   `    ``// Store nodes at  each level of` `    ``// the tree using BFS` `    ``queue que;` `    ``que.push(root);`   `    ``// Performing level order traversal` `    ``while` `(que.size() > 0)` `    ``{`   `        ``// Stores count of nodes at` `        ``// current level` `        ``int` `length = que.size();`   `        ``// Stores prefix XOR of all` `        ``// the nodes at current level` `        ``int` `prefix_XOR = 0;`   `        ``// Stores prefix OR of all` `        ``// the nodes at current level` `        ``int` `prefix_OR = 0;`   `        ``// Check if set bit of all the nodes` `        ``// at current level is at different` `        ``// positions or not` `        ``bool` `flag = ``true``;`   `        ``// Traverse nodes at current level` `        ``for``(``int` `i = 0; i < length; i++){`   `            ``// Stores front element` `            ``// of the que` `            ``TreeNode *temp = que.front();` `            ``que.pop();`   `            ``// Update prefix_OR` `            ``prefix_OR |= temp->val;`   `            ``// Update prefix_XOR` `            ``prefix_XOR ^= temp->val;` `            ``if` `(prefix_XOR != prefix_OR)` `                ``flag = ``false``;`   `            ``// If left subtree not NULL` `            ``if` `(temp->left)` `                ``que.push(temp->left);`   `            ``// If right subtree not NULL` `            ``if` `(temp->right)` `                ``que.push(temp->right);`   `            ``// Update length` `        ``}`   `        ``//If bitwise AND is zero` `        ``if` `(flag)` `            ``uniqueLevels += 1;` `      ``}` `    ``cout << uniqueLevels;` `}`   `// Driver Code` `int` `main()` `{` `  ``TreeNode *root = ``new` `TreeNode(5);` `  ``root->left = ``new` `TreeNode(6);` `  ``root->right = ``new` `TreeNode(9);` `  ``root->left->left = ``new` `TreeNode(1);` `  ``root->left->right = ``new` `TreeNode(4);` `  ``root->right->right = ``new` `TreeNode(7);`   `  ``// Function Call` `  ``uniqueLevels(root);` `  ``return` `0;` `}`   `// This code is contributed by mohit kumar 29.`

## Java

 `// Java program for the above approach` `import` `java.util.*;` `class` `GFG` `{`   `  ``// Structure of a node in` `  ``// the binary tree` `  ``static` `class` `TreeNode` `  ``{` `    ``int` `val = ``0``;` `    ``TreeNode left, right;` `    ``TreeNode(``int` `x)` `    ``{` `      ``val = x;` `      ``left = ``null``;` `      ``right = ``null``;` `    ``}` `  ``};`   `  ``// Function to find total unique levels` `  ``static` `void` `uniqueLevels(TreeNode root)` `  ``{`   `    ``// Stores count of levels, where the set` `    ``// bits of all the nodes are at` `    ``// different positions` `    ``int` `uniqueLevels = ``0``;`   `    ``// Store nodes at  each level of` `    ``// the tree using BFS` `    ``Queue que = ``new` `LinkedList<>();` `    ``que.add(root);`   `    ``// Performing level order traversal` `    ``while` `(que.size() > ``0``)` `    ``{`   `      ``// Stores count of nodes at` `      ``// current level` `      ``int` `length = que.size();`   `      ``// Stores prefix XOR of all` `      ``// the nodes at current level` `      ``int` `prefix_XOR = ``0``;`   `      ``// Stores prefix OR of all` `      ``// the nodes at current level` `      ``int` `prefix_OR = ``0``;`   `      ``// Check if set bit of all the nodes` `      ``// at current level is at different` `      ``// positions or not` `      ``boolean` `flag = ``true``;`   `      ``// Traverse nodes at current level` `      ``for``(``int` `i = ``0``; i < length; i++)` `      ``{`   `        ``// Stores front element` `        ``// of the que` `        ``TreeNode temp = que.peek();` `        ``que.remove();`   `        ``// Update prefix_OR` `        ``prefix_OR |= temp.val;`   `        ``// Update prefix_XOR` `        ``prefix_XOR ^= temp.val;` `        ``if` `(prefix_XOR != prefix_OR)` `          ``flag = ``false``;`   `        ``// If left subtree not null` `        ``if` `(temp.left != ``null``)` `          ``que.add(temp.left);`   `        ``// If right subtree not null` `        ``if` `(temp.right != ``null``)` `          ``que.add(temp.right);`   `        ``// Update length` `      ``}`   `      ``//If bitwise AND is zero` `      ``if` `(flag)` `        ``uniqueLevels += ``1``;` `    ``}` `    ``System.out.print(uniqueLevels);` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``TreeNode root = ``new` `TreeNode(``5``);` `    ``root.left = ``new` `TreeNode(``6``);` `    ``root.right = ``new` `TreeNode(``9``);` `    ``root.left.left = ``new` `TreeNode(``1``);` `    ``root.left.right = ``new` `TreeNode(``4``);` `    ``root.right.right = ``new` `TreeNode(``7``);`   `    ``// Function Call` `    ``uniqueLevels(root);` `  ``}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python program for the above approach`     `# Structure of a node in` `# the binary tree` `class` `TreeNode:` `    ``def` `__init__(``self``, val ``=` `0``, left ``=` `None``, right ``=` `None``):` `        ``self``.val ``=` `val` `        ``self``.left ``=` `left` `        ``self``.right ``=` `right`   `# Function to find total unique levels` `def` `uniqueLevels(root):`   `    ``# Stores count of levels, where the set` `    ``# bits of all the nodes are at ` `    ``# different positions ` `    ``uniqueLevels ``=` `0`   `    ``# Store nodes at  each level of ` `    ``# the tree using BFS` `    ``que ``=` `[root]`   `    ``# Performing level order traversal` `    ``while` `len``(que):` `    `  `        ``# Stores count of nodes at` `        ``# current level` `        ``length ``=` `len``(que)`   `        ``# Stores prefix XOR of all ` `        ``# the nodes at current level` `        ``prefix_XOR ``=` `0``;`   `        ``# Stores prefix OR of all ` `        ``# the nodes at current level` `        ``prefix_OR ``=` `0`   `        ``# Check if set bit of all the nodes ` `        ``# at current level is at different` `        ``# positions or not` `        ``flag ``=` `True`   `        ``# Traverse nodes at current level` `        ``while` `length:`   `            ``# Stores front element` `            ``# of the que` `            ``temp ``=` `que.pop(``0``)`   `            ``# Update prefix_OR` `            ``prefix_OR |``=` `temp.val`   `            ``# Update prefix_XOR` `            ``prefix_XOR ^``=` `temp.val`   `            ``if` `prefix_XOR !``=` `prefix_OR:` `                ``flag ``=` `False` `            `  `            ``# If left subtree not NULL` `            ``if` `temp.left:` `                ``que.append(temp.left)`   `            ``# If right subtree not NULL    ` `            ``if` `temp.right:` `                ``que.append(temp.right)`   `            ``# Update length    ` `            ``length ``-``=` `1`   `        ``# If bitwise AND is zero` `        ``if` `flag:` `            ``uniqueLevels ``+``=` `1`   `    ``print``(uniqueLevels)`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``root ``=` `TreeNode(``5``)` `    ``root.left ``=` `TreeNode(``6``)` `    ``root.right ``=` `TreeNode(``9``)` `    ``root.left.left ``=` `TreeNode(``1``)` `    ``root.left.right ``=` `TreeNode(``4``)` `    ``root.right.right ``=` `TreeNode(``7``)`   `    ``# Function Call` `    ``uniqueLevels(root)`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;` `public` `class` `GFG` `{`   `  ``// Structure of a node in` `  ``// the binary tree` `  ``class` `TreeNode` `  ``{` `    ``public` `int` `val = 0;` `    ``public` `TreeNode left, right;` `    ``public` `TreeNode(``int` `x)` `    ``{` `      ``val = x;` `      ``left = ``null``;` `      ``right = ``null``;` `    ``}` `  ``};`   `  ``// Function to find total unique levels` `  ``static` `void` `uniqueLevels(TreeNode root)` `  ``{`   `    ``// Stores count of levels, where the set` `    ``// bits of all the nodes are at` `    ``// different positions` `    ``int` `uniqueLevels = 0;`   `    ``// Store nodes at  each level of` `    ``// the tree using BFS` `    ``Queue que = ``new` `Queue();` `    ``que.Enqueue(root);`   `    ``// Performing level order traversal` `    ``while` `(que.Count > 0)` `    ``{`   `      ``// Stores count of nodes at` `      ``// current level` `      ``int` `length = que.Count;`   `      ``// Stores prefix XOR of all` `      ``// the nodes at current level` `      ``int` `prefix_XOR = 0;`   `      ``// Stores prefix OR of all` `      ``// the nodes at current level` `      ``int` `prefix_OR = 0;`   `      ``// Check if set bit of all the nodes` `      ``// at current level is at different` `      ``// positions or not` `      ``bool` `flag = ``true``;`   `      ``// Traverse nodes at current level` `      ``for``(``int` `i = 0; i < length; i++)` `      ``{`   `        ``// Stores front element` `        ``// of the que` `        ``TreeNode temp = que.Peek();` `        ``que.Dequeue();`   `        ``// Update prefix_OR` `        ``prefix_OR |= temp.val;`   `        ``// Update prefix_XOR` `        ``prefix_XOR ^= temp.val;` `        ``if` `(prefix_XOR != prefix_OR)` `          ``flag = ``false``;`   `        ``// If left subtree not null` `        ``if` `(temp.left != ``null``)` `          ``que.Enqueue(temp.left);`   `        ``// If right subtree not null` `        ``if` `(temp.right != ``null``)` `          ``que.Enqueue(temp.right);`   `        ``// Update length` `      ``}`   `      ``//If bitwise AND is zero` `      ``if` `(flag)` `        ``uniqueLevels += 1;` `    ``}` `    ``Console.Write(uniqueLevels);` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(String[] args)` `  ``{` `    ``TreeNode root = ``new` `TreeNode(5);` `    ``root.left = ``new` `TreeNode(6);` `    ``root.right = ``new` `TreeNode(9);` `    ``root.left.left = ``new` `TreeNode(1);` `    ``root.left.right = ``new` `TreeNode(4);` `    ``root.right.right = ``new` `TreeNode(7);`   `    ``// Function Call` `    ``uniqueLevels(root);` `  ``}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`2`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles