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

• Difficulty Level : Easy
• Last Updated : 18 Aug, 2021

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:

## C++

 `// C++ program to calculate the maximum number of leaf` `// nodes that can be visited within the given budget` `#include ` `using` `namespace` `std;`   `// struct that represents a node of the tree` `struct` `Node {` `    ``Node* left;` `    ``Node* right;` `    ``int` `data;` ` `  `    ``Node(``int` `key)` `    ``{` `        ``data = key;` `        ``this``->left = nullptr;` `        ``this``->right = nullptr;` `    ``}` `};`   `Node* newNode(``int` `key)` `{` `    ``Node* temp = ``new` `Node(key);` `    ``return` `temp;` `}` ` `  `// Priority queue to store the levels` `// of all the leaf nodes` `vector<``int``> pq;`   `// Level order traversal of the binary tree` `void` `levelOrder(Node* root)` `{` `    ``vector q;` `    ``int` `len, level = 0;` `    ``Node* temp;`   `    ``// If tree is empty` `    ``if` `(root == nullptr)` `        ``return``;`   `    ``q.push_back(root);`   `    ``while` `(``true``) {`   `        ``len = q.size();` `        ``if` `(len == 0)` `            ``break``;` `        ``level++;` `        ``while` `(len > 0) {`   `            ``temp = q;` `            ``q.erase(q.begin());`   `            ``// If left child exists` `            ``if` `(temp->left != nullptr)` `                ``q.push_back(temp->left);`   `            ``// If right child exists` `            ``if` `(temp->right != nullptr)` `                ``q.push_back(temp->right);`   `            ``// If node is a leaf node` `            ``if` `(temp->left == nullptr && temp->right == nullptr)` `            ``{` `                ``pq.push_back(level);` `                ``sort(pq.begin(), pq.end());` `                ``reverse(pq.begin(), pq.end());` `            ``}` `            ``len--;` `        ``}` `    ``}` `}`   `// Function to calculate the maximum number of leaf nodes` `// that can be visited within the given budget` `int` `countLeafNodes(Node* root, ``int` `budget)` `{` `    ``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;` `        ``pq.erase(pq.begin());`   `        ``// 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` `int` `main()` `{` `    ``Node* root = newNode(10);` `    ``root->left = newNode(8);` `    ``root->right = newNode(15);` `    ``root->left->left = newNode(3);` `    ``root->left->left->right = newNode(13);` `    ``root->right->left = newNode(11);` `    ``root->right->right = newNode(18);` ` `  `    ``int` `budget = 8;` ` `  `    ``cout << countLeafNodes(root, budget);`   `    ``return` `0;` `}`   `// This code is contributed by decode2207.`

## 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));` `    ``}` `}`

## Python3

 `# Python3 program to calculate the maximum number of leaf` `# nodes that can be visited within the given budget`   `# struct that represents a node of the tree` `class` `Node:` `    ``# Constructor to set the data of` `    ``# the newly created tree node` `    ``def` `__init__(``self``, key):` `        ``self``.data ``=` `key` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# Priority queue to store the levels` `# of all the leaf nodes` `pq ``=` `[]`   `# Level order traversal of the binary tree` `def` `levelOrder(root):`   `    ``q ``=` `[]` `    ``level ``=` `0`   `    ``# If tree is empty` `    ``if` `(root ``=``=` `None``):` `        ``return`   `    ``q.append(root)`   `    ``while` `(``True``) :`   `        ``Len` `=` `len``(q)` `        ``if` `(``Len` `=``=` `0``):` `            ``break` `        ``level``+``=``1` `        ``while` `(``Len` `> ``0``) :`   `            ``temp ``=` `q[``0``]` `            ``del` `q[``0``]`   `            ``# If left child exists` `            ``if` `(temp.left !``=` `None``):` `                ``q.append(temp.left)`   `            ``# If right child exists` `            ``if` `(temp.right !``=` `None``):` `                ``q.append(temp.right)`   `            ``# If node is a leaf node` `            ``if` `(temp.left ``=``=` `None` `and` `temp.right ``=``=` `None``):` `            `  `                ``pq.append(level)` `                ``pq.sort()` `                ``pq.reverse()` `            `  `            ``Len``-``=``1` `    `  `    ``return` `pq`   `# Function to calculate the maximum number of leaf nodes` `# that can be visited within the given budget` `def` `countLeafNodes(root, budget):`   `    ``pq ``=` `levelOrder(root)`   `    ``# Variable to store the count of` `    ``# number of leaf nodes possible to visit` `    ``# within the given budget` `    ``count ``=` `0`   `    ``while` `(``len``(pq) !``=` `0``) :`   `        ``# Removing element from` `        ``# min priority queue one by one` `        ``val ``=` `pq[``0``]` `        ``del` `pq[``0``]`   `        ``# If current val is under budget, the` `        ``# node can be visited` `        ``# Update the budget afterwards` `        ``if` `(val <``=` `budget) :` `            ``count``+``=``1` `            ``budget ``-``=` `val` `        `  `        ``else``:` `            ``break` `        `  `    ``return` `count`   `root ``=` `Node(``10``)` `root.left ``=` `Node(``8``)` `root.right ``=` `Node(``15``);` `root.left.left ``=` `Node(``3``)` `root.left.left.right ``=` `Node(``13``)` `root.right.left ``=` `Node(``11``)` `root.right.right ``=` `Node(``18``)`   `budget ``=` `8`   `print``(countLeafNodes(root, budget))`   `# This code is contributed by suresh07.`

## C#

 `// C# program to calculate the maximum number of leaf` `// nodes that can be visited within the given budget` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG {` `    `  `    ``// Class that represents a node of the tree` `    ``class` `Node` `    ``{` `        ``public` `Node left, right;` `        ``public` `int` `data;` `    ``};` `    `  `    ``static` `Node newNode(``int` `key)` `    ``{` `        ``Node temp = ``new` `Node();` `        ``temp.data = key;` `        ``temp.left = temp.right = ``null``;` `        ``return` `temp;` `    ``}` `    `  `    ``// Priority queue to store the levels` `    ``// of all the leaf nodes` `    ``static` `List<``int``> pq;` ` `  `    ``// Level order traversal of the binary tree` `    ``static` `void` `levelOrder(Node root)` `    ``{` `        ``List q = ``new` `List();` `        ``int` `len, level = 0;` `        ``Node temp;` ` `  `        ``// If tree is empty` `        ``if` `(root == ``null``)` `            ``return``;` ` `  `        ``q.Add(root);` ` `  `        ``while` `(``true``) {` ` `  `            ``len = q.Count;` `            ``if` `(len == 0)` `                ``break``;` `            ``level++;` `            ``while` `(len > 0) {` ` `  `                ``temp = q;` `                ``q.RemoveAt(0);` ` `  `                ``// 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);` `                    ``pq.Sort();` `                    ``pq.Reverse();` `                ``}` `                ``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` `List<``int``>();` `        ``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.Count != 0) {` ` `  `            ``// Removing element from` `            ``// min priority queue one by one` `            ``val = pq;` `            ``pq.RemoveAt(0);` ` `  `            ``// 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;` `    ``}`   `  ``static` `void` `Main() {` `    ``Node root = newNode(10);` `    ``root.left = newNode(8);` `    ``root.right = newNode(15);` `    ``root.left.left = newNode(3);` `    ``root.left.left.right = newNode(13);` `    ``root.right.left = newNode(11);` `    ``root.right.right = newNode(18);`   `    ``int` `budget = 8;`   `    ``Console.Write(countLeafNodes(root, budget));` `  ``}` `}`   `// This code is contributed by divyeshrabadiya07.`

## Javascript

 ``

Output:

`2`

My Personal Notes arrow_drop_up
Recommended Articles
Page :