Related Articles
Maximum number of leaf nodes that can be visited within the given budget
• Difficulty Level : Easy
• Last Updated : 27 Dec, 2018

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.
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

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:

 `// 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));``    ``}``}`
Output:
```2
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up