- Trending Categories
- Data Structure
- Networking
- RDBMS
- Operating System
- Java
- iOS
- HTML
- CSS
- Android
- Python
- C Programming
- C++
- C#
- MongoDB
- MySQL
- Javascript
- PHP

- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who

# C++ program to remove Nodes that Don't Lie in Any Path With Sum>=k

In this problem, we have a binary tree with a path from the root node to the leaf node that is completely defined. The sum of all nodes from the root node to the leaf node must be greater than or equal to, a constant value, k. So we need to remove all nodes in those paths whose sum is less than k, such that the only paths left in the tree will be greater than k. An important thing to remember here is that a node may be a part of many paths, so only remove such nodes if all the paths leading to that node have a sum < k.

From the root node to the leaf node, we can calculate the sum. When the recursive call completes for a node and control returns, we can check if the sum is < k for both left and right paths. If the sum is less than k for both the left and right paths, we need to remove this node.

Let's suppose we have 150 K and a tree like this −

10 /\ 20 30 /\ /\ 5 35 40 45 /\ /\ 50 55 60 65 /\ / / 70 80 90 100

If we see that the path root->left->left has a sum of 10 + 20 + 5, which is 25, less than 150, we need to prune it and remove 5. After this, let's evaluate 10->30->40. It's less than 150, so remove 40.

Now we see another path 10->20->35->50 and the total sum 115 which is less than 150, so we remove 50. Now the remaining paths we have are

10->20->35->55->70 ; 10->20->35->55->80 ; 10->30->45->60->90 ; 10->30->45->65->100 ;

The sum of all paths is greater than 150, so we don't need to prune anymore.

## Example

Following is a C++ program demonstrating how to remove nodes that don't lie in any path whose sum is greater than or equal to any constant value k −

#include <iostream> using namespace std; class Node { public: int value; Node *left, *right; Node(int value) { this->value = value; left = right = NULL; } }; Node* removeNodesWithPathSumLessThanK(Node* root, int k, int& sum) { if(root == NULL) return NULL; int leftSum, rightSum; leftSum = rightSum = sum + root->value; root->left = removeNodesWithPathSumLessThanK(root->left, k, leftSum); root->right = removeNodesWithPathSumLessThanK(root->right, k, rightSum); sum = max(leftSum, rightSum); if(sum < k) { free(root); root = NULL; } return root; } void printInorderTree(Node* root) { if(root) { printInorderTree(root->left); cout << root->value << " "; printInorderTree(root->right); } } int main() { int k = 150; Node* root = new Node(10); root->left = new Node(20); root->right = new Node(30); root->left->left = new Node(5); root->left->right = new Node(35); root->right->left = new Node(40); root->right->right = new Node(45); root->left->right->left = new Node(50); root->left->right->right = new Node(55); root->right->right->left = new Node(60); root->right->right->right = new Node(65); root->left->right->right->left = new Node(70); root->left->right->right->right = new Node(80); root->right->right->left->left = new Node(90); root->right->right->right->left = new Node(100); int sum = 0; cout << "Inorder tree before: "; printInorderTree(root); root = removeNodesWithPathSumLessThanK(root, k, sum); cout << "

Inorder tree after: "; printInorderTree(root); return 0; }

## Output

Inorder tree before: 5 20 50 35 70 55 80 10 40 30 90 60 45 100 65 Inorder tree after: 20 35 70 55 80 10 30 90 60 45 100 65

Tree after we pruned it completely −

10 / \ 20 30 \ \ 35 45 \ /\ 55 60 65 /\ / / 70 80 90 100

## Conclusion

As we can see that after the initial observation, we can apply the DFS and remove nodes as our recursive function returns from each call by computing the sum at that node. Overall a simple observational and methodological problem.

- Related Questions & Answers
- Remove All Nodes Which Don't Lie in Any Path With Sum>=k using C++
- Handshakes That Don't Cross in C++
- Why I don’t get that feel when I say any swear word (gaali) in English?
- Count BST nodes that lie in a given range in C++
- Delete leaf nodes with value k in C++ program
- Program to count subsets that sum up to k in python
- Algorithm to sum ranges that lie within another separate range in JavaScript
- Maximum path sum that starting with any cell of 0-th row and ending with any cell of (N-1)-th row in C++
- Program to find largest sum of any path of a binary tree in Python
- Find pairs with given sum such that pair elements lie in different BSTs in Python
- Print path between any two nodes in a Binary Tree in C++ Programming.
- Shortest path with exactly k Edges
- What are some signs that tell me that I don't have enough protein in my diet?
- MySQL stored procedure parameters don't seem to work with special character @?
- Find minimum radius such that atleast k point lie inside the circle in C++
- Path with smallest sum in JavaScript