给定一个由N个节点组成的二叉树，任务是对二叉树中的级别数进行计数，以使同一级别上所有节点值的设置位位于不同的位置。
例子：
Input:
Output: 2
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:
Output: 1
天真的方法：解决此问题的最简单方法是使用级别顺序遍历遍历二叉树，并在树的每个级别使用Map存储所有节点的设置位。遍历该映射，并检查同一位置的置位频率是否小于或等于1。如果发现为真，则增加计数。最后，打印获得的计数。
时间复杂度： O(N)
辅助空间： O(32)
高效的方法：可以基于以下观察来优化上述方法：
If all the set bits of two numbers A and B are at different positions
A XOR B = A OR B
请按照以下步骤解决问题：
- 初始化一个变量，例如prefiX_XOR ，以存储每个级别上所有节点的前缀XOR。
- 初始化一个变量，例如prefiX_OR ，以存储每个级别上所有节点的前缀OR。
- 使用级别顺序遍历遍历二叉树。在每个第i级别，检查prefix_XOR ^节点是否等于(prefix_OR |节点) 。如果发现对于当前级别的所有节点都是正确的，则增加计数。
- 最后，打印获得的计数。
下面是上述方法的实现：
C++14
5
/ \
6 9
/ \ \
1 4 7Java
1
/ \
2 3
/ \ \
5 4 7Python3
// 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. C#
// 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 输出：
# 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)时间复杂度： O(N)
辅助空间： O(1)