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

给定一个二叉树和一个表示预算的整数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.

方法：

• 使用层序遍历遍历二叉树，将所有叶子节点的层级存储在一个优先级队列中。
• 将优先级队列中的一个元素一个一个取出，检查这个值是否在预算范围内。
• 如果是，则从预算中减去该值并更新count = count + 1 。
• 否则，打印在给定预算内可以访问的最大叶节点数。

下面是上述方法的实现：

Java

// 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));
    }
}

Javascript

 
    // JavaScript program to calculate
    // the maximum number of leaf
    // nodes that can be visited within the given budget
     
    // Class that represents a node of the tree
    class Node {
        constructor(data) {
           this.left = null;
           this.right = null;
           this.data = data;
        }
    }
     
    // Priority queue to store the levels
    // of all the leaf nodes
    let pq = [];
   
    // Level order traversal of the binary tree
    function levelOrder(root)
    {
        let q = [];
        let len, level = 0;
        let temp;
   
        // If tree is empty
        if (root == null)
            return;
   
        q.push(root);
   
        while (true) {
   
            len = q.length;
            if (len == 0)
                break;
            level++;
            while (len > 0) {
   
                temp = q.shift();
   
                // If left child exists
                if (temp.left != null)
                    q.push(temp.left);
   
                // If right child exists
                if (temp.right != null)
                    q.push(temp.right);
   
                // If node is a leaf node
                if (temp.left == null && temp.right == null)
                {
                    pq.push(level);
                    pq.sort(function(a, b){return a - b});
                    pq.reverse();
                }
                len--;
            }
        }
    }
   
    // Function to calculate the maximum number of leaf nodes
    // that can be visited within the given budget
    function countLeafNodes(root, budget)
    {
        pq = [];
        levelOrder(root);
        let val;
   
        // Variable to store the count of
        // number of leaf nodes possible to visit
        // within the given budget
        let count = 0;
   
        while (pq.length != 0) {
   
            // Removing element from
            // min priority queue one by one
            val = pq[0];
            pq.shift();
   
            // 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;
    }
     
    let 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);
 
    let budget = 8;
 
    document.write(countLeafNodes(root, budget));
 

输出：

2

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