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:
// Java program to calculate the maximum number of leaf// nodes that can be visited within the given budgetimport java.io.*;import java.util.*;import java.lang.*; // Class that represents a node of the treeclass 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)); }} |
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.
