在给定的预算内可以访问的最大叶节点数

给定一个二叉树和一个表示预算的整数b。如果访问叶子节点的成本等于该叶子节点的级别，则任务是查找在给定的预算下可以访问的最大叶子节点的数量。
注意：树的根在1级。

例子：

Input: b = 8
           10
         /    \
        8       15
       /      /   \
      3      11     18 
              \
               13
Output: 2
For the above binary tree, leaf nodes are 3, 
13 and 18 at levels 3, 4 and 3 respectively.
Cost for visiting leaf node 3 is 3
Cost for visiting leaf node 13 is 4
Cost for visiting leaf node 18 is 3
Thus with given budget = 8, we can at maximum
visit two leaf nodes.

Input: b = 1
           8
         /   \
        7     10
       /      
      3      
             
Output: 0 
For the above binary tree, leaf nodes are
3 and 10 at levels 3 and 2 respectively.
Cost for visiting leaf node 3 is 3
Cost for visiting leaf node 10 is 2
In given budget = 1, we can't visit
any leaf node.

方法：

• 使用级别顺序遍历遍历二叉树，并将所有叶节点的级别存储在优先级队列中。
• 从优先级队列中一个接一个地删除一个元素，检查该值是否在预算之内。
• 如果是，则从预算中减去此值，然后更新计数=计数+ 1 。
• 否则，打印在给定预算内可以访问的最大叶节点数。

下面是上述方法的实现：

// Java program to calculate the maximum number of leaf
// nodes that can be visited within the given budget
import java.io.*;
import java.util.*;
import java.lang.*;
  
// Class that represents a node of the tree
class Node {
    int data;
    Node left, right;
  
    // Constructor to create a new tree node
    Node(int key)
    {
        data = key;
        left = right = null;
    }
}
  
class GFG {
  
    // Priority queue to store the levels
    // of all the leaf nodes
    static PriorityQueue pq;
  
    // Level order traversal of the binary tree
    static void levelOrder(Node root)
    {
        Queue q = new LinkedList<>();
        int len, level = 0;
        Node temp;
  
        // If tree is empty
        if (root == null)
            return;
  
        q.add(root);
  
        while (true) {
  
            len = q.size();
            if (len == 0)
                break;
            level++;
            while (len > 0) {
  
                temp = q.remove();
  
                // If left child exists
                if (temp.left != null)
                    q.add(temp.left);
  
                // If right child exists
                if (temp.right != null)
                    q.add(temp.right);
  
                // If node is a leaf node
                if (temp.left == null && temp.right == null)
                    pq.add(level);
                len--;
            }
        }
    }
  
    // Function to calculate the maximum number of leaf nodes
    // that can be visited within the given budget
    static int countLeafNodes(Node root, int budget)
    {
        pq = new PriorityQueue<>();
        levelOrder(root);
        int val;
  
        // Variable to store the count of
        // number of leaf nodes possible to visit
        // within the given budget
        int count = 0;
  
        while (pq.size() != 0) {
  
            // Removing element from
            // min priority queue one by one
            val = pq.poll();
  
            // If current val is under budget, the
            // node can be visited
            // Update the budget afterwards
            if (val <= budget) {
                count++;
                budget -= val;
            }
            else
                break;
        }
        return count;
    }
  
    // Driver code
    public static void main(String args[])
    {
  
        Node root = new Node(10);
        root.left = new Node(8);
        root.right = new Node(15);
        root.left.left = new Node(3);
        root.left.left.right = new Node(13);
        root.right.left = new Node(11);
        root.right.right = new Node(18);
  
        int budget = 8;
  
        System.out.println(countLeafNodes(root, budget));
    }
}

输出：

2