Count all k-sum paths in a Binary Tree - GeeksforGeeks

29 Jun, 2021
Given a binary tree and an integer k. The task is to count the number of paths in the tree with the sum of the nodes equals to k. A path can start from any node and end at any node and must be downward only, i.e. they need not be root node and leaf node, and negative numbers can also be there in the tree.
Examples:  
Input : k = 5  
        Root of below binary tree:
           1
        /     \
      3        -1
    /   \     /   \
   2     1   4     5                        
        /   / \     \                    
       1   1   2     6    
                       
Output : No of paths with sum equals to 5 are: 8
3 2 
3 1 1 
1 3 1 
4 1 
1 -1 4 1 
-1 4 2 
5 
1 -1 5 

Input : k = 3
           1
        /     \
      2       -1
    /   \     /   
   1     2   3                             
            / \                         
           2   5        
Output : No of paths with sum equals to 3 are : 4
Approach : The implementation of printing paths with path sum equal to k is already discussed in this post using vector. However, storing in vector and recursively moving increases both space and time complexity if we just want to store the count of such pathsAn efficient implementation of the above problem can be done in using backtracking and unordered maps. 
Steps:  
We will be using a unordered map which will be filled with various path sum.
For every node we will check if current sum and root’s value equal to k or not. If the sum equals to k then increment the required answer by one.
Then we will add all those path sum in map which differs from current sum+root->data value by a constant integer k.
Then we will be inserting the current sum + root->data value in the map.
We will recursively check for left and right subtrees of current root
After the right subtree is also traversed we will remove the current sum + root->data value from the map so that it is not taken into consideration in further traversals of other nodes other than the current root’s
Below is the implementation of the above approach:
C++
Java
Python3
Javascript
// C++ program to count the number// of paths with sum equals to k#include <bits/stdc++.h>using namespace std; // Binary tree nodestruct Node {    int data;    Node *left, *right;    Node(int x)    {        data = x;        left = right = NULL;    }}; // Function to backtrack the tree path and// add each path sum in the unordered mapvoid k_paths(Node* root, int k, unordered_map<int, int>& p,                                         int sum, int &res){    // If root is not null    if (root)    {        // If root value and previous sum equal        // to k then increase the count         if (sum + root->data == k)            res++;                 // Add those values also which differes        // by the current sum and root data by k        res += p[sum + root->data - k];                 // Insert the sum + root value in the map        p[sum + root->data]++;         // Move to left and right trees        k_paths(root->left, k, p, sum + root->data, res);        k_paths(root->right, k, p, sum + root->data, res);                 // remove the sum + root->data value from the        // map if they are n not required further or        // they do no sum up to k in any way        p[sum + root->data]--;    }} // Function to print the count// of paths with sum equals to kint printCount(Node* root, int k){    // To store the required answer    int res = 0;         // To store the sum    unordered_map<int, int> p;         // Function call    k_paths(root, k, p, 0, res);         // Return the required answer    return res;} // Driver codeint main(){    Node* root = new Node(1);    root->left = new Node(2);    root->left->left = new Node(1);    root->left->right = new Node(2);    root->right = new Node(-1);    root->right->left = new Node(3);    root->right->left->left = new Node(2);    root->right->left->right = new Node(5);     int k = 3;    cout << "No of paths with sum equals to " <<  k         << " are : "  << printCount(root, k) << "\n";     return 0;}
// Java program to print all root to leaf// paths with there relative positionimport java.util.ArrayList;import java.util.HashMap; class Graph{ static int res; // tree structurestatic class Node{    int data;    Node left, right;     public Node(int data)    {        this.data = data;        this.left = this.right = null;    }}; // Function to backtrack the tree path and// add each path sum in the unordered mapstatic void k_paths(Node root, int k,  HashMap<Integer, Integer> p, int sum){         // If root is not null    if (root != null)    {                 // If root value and previous sum equal        // to k then increase the count        if (sum + root.data == k)            res++;         // Add those values also which differes        // by the current sum and root data by k        res += p.get(sum + root.data - k) == null ?           0 : p.get(sum + root.data - k);         // Insert the sum + root value in the map        if (!p.containsKey(sum + root.data))        {            p.put(sum + root.data, 0);        }        p.put(sum + root.data,        p.get(sum + root.data) + 1);         // Move to left and right trees        k_paths(root.left, k, p,                sum + root.data);        k_paths(root.right, k, p,                sum + root.data);         // Remove the sum + root.data value        // from the map if they are n not        // required further or they do no        // sum up to k in any way        p.put(sum + root.data,        p.get(sum + root.data) - 1);    }} // Function to print the count// of paths with sum equals to kstatic int printCount(Node root, int k){         // To store the sum    HashMap<Integer, Integer> p = new HashMap<>();     // Function call    k_paths(root, k, p, 0);     // Return the required answer    return res;} // Driver codepublic static void main(String[] args){    res = 0;    Node root = new Node(1);    root.left = new Node(2);    root.left.left = new Node(1);    root.left.right = new Node(2);    root.right = new Node(-1);    root.right.left = new Node(3);    root.right.left.left = new Node(2);    root.right.left.right = new Node(5);     int k = 3;    System.out.printf("No of paths with sum " +                      "equals to %d are: %d\n", k,                      printCount(root, k));}} // This code is contributed by sanjeev2552
# Python program to count the number# of paths with sum equals to k # Binary tree nodefrom typing import Dictclass Node:    def __init__(self, x: int) -> None:        self.data = x        self.left = None        self.right = Noneres = 0 # Function to backtrack the tree path and# add each path sum in the unordered mapdef k_paths(root: Node, k: int, p: Dict, sum: int) -> None:    global res         # If root is not null    if (root):         # If root value and previous sum equal        # to k then increase the count        if (sum + root.data == k):            res += 1         # Add those values also which differes        # by the current sum and root data by k        val = sum + root.data - k        if val in p:            res += p[val]        else:            res += 0         # Insert the sum + root value in the map        if (sum + root.data) not in p:            p[sum + root.data] = 0        p[sum + root.data] += 1         # Move to left and right trees        k_paths(root.left, k, p, sum + root.data)        k_paths(root.right, k, p, sum + root.data)         # remove the sum + root.data value from the        # map if they are n not required further or        # they do no sum up to k in any way        p[sum + root.data] -= 1 # Function to print the count# of paths with sum equals to kdef printCount(root: Node, k: int) -> int:     # To store the required answer    global res     # To store the sum    p = dict()     # Function call    k_paths(root, k, p, 0)     # return res # Driver codeif __name__ == "__main__":    root = Node(1)    root.left = Node(2)    root.left.left = Node(1)    root.left.right = Node(2)    root.right = Node(-1)    root.right.left = Node(3)    root.right.left.left = Node(2)    root.right.left.right = Node(5)     k = 3    printCount(root, k)    print("No of paths with sum equals to {} are : {}".format(k, res)) # This code is contributed by sanjeev2552
<script> // Javascript program to print all root to leaf// paths with there relative positionlet res; // Tree structureclass Node{    constructor(data)    {        this.left = null;        this.right = null;        this.data = data;    }} // Function to backtrack the tree path and// add each path sum in the unordered mapfunction k_paths(root, k, p, sum){         // If root is not null    if (root != null)    {         // If root value and previous sum equal        // to k then increase the count        if (sum + root.data == k)            res++;         // Add those values also which differes        // by the current sum and root data by k        res += p.get(sum + root.data - k) == null ?           0 : p.get(sum + root.data - k);         // Insert the sum + root value in the map        if (!p.has(sum + root.data))        {            p.set(sum + root.data, 0);        }        p.set(sum + root.data,        p.get(sum + root.data) + 1);         // Move to left and right trees        k_paths(root.left, k, p,                sum + root.data);        k_paths(root.right, k, p,                sum + root.data);         // Remove the sum + root.data value        // from the map if they are n not        // required further or they do no        // sum up to k in any way        p.set(sum + root.data,        p.get(sum + root.data) - 1);    }} // Function to print the count// of paths with sum equals to kfunction printCount(root, k){         // To store the sum    let p = new Map();     // Function call    k_paths(root, k, p, 0);     // Return the required answer    return res;} // Driver coderes = 0;let root = new Node(1);root.left = new Node(2);root.left.left = new Node(1);root.left.right = new Node(2);root.right = new Node(-1);root.right.left = new Node(3);root.right.left.left = new Node(2);root.right.left.right = new Node(5); let k = 3;document.write("No of paths with sum " +               "equals to " + k + " are: " +               printCount(root, k)); // This code is contributed by divyeshrabadiya07 </script>
No of paths with sum equals to 3 are : 4
 
sanjeev2552
divyeshrabadiya07
Binary Tree
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Tree Data Structure
Find maximum (or minimum) in Binary Tree
DFS traversal of a tree using recursion
Threaded Binary Tree
Find the node with minimum value in a Binary Search Tree
Top 50 Tree Coding Problems for Interviews
Iterative Postorder Traversal | Set 2 (Using One Stack)
Difference between Min Heap and Max Heap
Iterative Preorder Traversal
Overview of Data Structures | Set 2 (Binary Tree, BST, Heap and Hash)