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