Maximum number of leaf nodes that can be visited within the given budget

Given a binary tree and an integer b representing budget. The task is to find the count of maximum number of leaf nodes that can be visited under the given budget if cost of visiting a leaf node is equal to level of that leaf node.
Note: Root of the tree is at level 1.

Examples:

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.

Approach:



  • Traverse the binary tree using level order traversal, and store the level of all the leaf nodes in a priority queue.
  • Remove an element from the priority queue one by one, check if this value is within the budget.
  • If Yes then subtract this value from the budget and update count = count + 1.
  • Else, print the count of maximum leaf nodes that can be visited within the given budget.

Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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<Integer> pq;
  
    // Level order traversal of the binary tree
    static void levelOrder(Node root)
    {
        Queue<Node> 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));
    }
}

chevron_right


Output:

2


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.