计算由在不同位置设置位的节点值组成的二叉树中的级别

给定一个由N 个节点组成的二叉树，任务是计算二叉树中的层数，使得同一层的所有节点值的集合位在不同的位置。

例子：

Input:

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

Input:

Output: 1

编程需要懂一点英语

朴素的方法：解决这个问题的最简单的方法是使用层序遍历来遍历二叉树，并在树的每一层使用 Map 存储所有节点的集合位。遍历map，检查同一位置set-bit的频率是否小于等于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 | nodes) 。如果发现当前级别的所有节点都为真，则增加计数。
最后，打印获得的计数。

下面是上述方法的实现：

C++14

Java

Python3

// 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

Javascript

# 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# 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

时间复杂度： O(N)
辅助空间： O(1)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。