Open In App

Count all k-sum paths in a Binary Tree

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 paths
An efficient implementation of the above problem can be done in using backtracking and unordered maps

Steps:  

Below is the implementation of the above approach:




#include <iostream>
#include <unordered_map>
 
using namespace std;
 
static int res = 0;
 
// tree structure
struct Node {
    int data;
    Node *left, *right;
 
    Node(int data) : data(data), left(nullptr), right(nullptr) {}
};
 
// Function to backtrack the tree path and add each path sum in the unordered map
static void k_paths(Node *root, int k, unordered_map<int, int> &p, int sum) {
    // If root is not null
    if (root != nullptr) {
        // If root value and previous sum equal to k then increase the count
        if (sum + root->data == k)
            res++;
 
        // Add those values also which differ 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);
        k_paths(root->right, k, p, sum + root->data);
 
        // Remove the sum + root.data value from the map if they are not required further
        // or they do not sum up to k in any way
        p[sum + root->data]--;
    }
}
 
// Function to print the count of paths with sum equals to k
static int printCount(Node *root, int k) {
    // To store the sum
    unordered_map<int, int> p;
 
    // Function call
    k_paths(root, k, p, 0);
 
    // Return the required answer
    return res;
}
 
int main() {
    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 = 5;
    cout << "No of paths with sum equals to " << k << " are: " << printCount(root, k) << endl;
 
    // Deallocate memory
    delete root->right->left->right;
    delete root->right->left->left;
    delete root->right->left;
    delete root->right;
    delete root->left->right;
    delete root->left->left;
    delete root->left;
    delete root;
 
    return 0;
}




// Java program to print all root to leaf
// paths with there relative position
import java.util.ArrayList;
import java.util.HashMap;
 
class Graph{
 
static int res;
 
// tree structure
static 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 map
static 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 differs
        // 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 k
static 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 code
public 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 node
from typing import Dict
class Node:
    def __init__(self, x: int) -> None:
        self.data = x
        self.left = None
        self.right = None
res = 0
 
# Function to backtrack the tree path and
# add each path sum in the unordered map
def 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 differs
        # 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 k
def 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 code
if __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




//C# code for the above approach
using System;
using System.Collections.Generic;
 
class Graph
{
    static int res;
 
    // tree structure
    class Node
    {
        public int data;
        public 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 dictionary
    static void k_paths(Node root, int k,
        Dictionary<int, int> 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 differs
            // by the current sum and root data by k
            res += p.ContainsKey(sum + root.data - k) ?
                p[sum + root.data - k] : 0;
 
            // Insert the sum + root value in the dictionary
            if (!p.ContainsKey(sum + root.data))
            {
                p.Add(sum + root.data, 0);
            }
            p[sum + root.data]++;
 
            // 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 dictionary if they are 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 k
    static int printCount(Node root, int k)
    {
         
        // To store the sum
        Dictionary<int, int> p = new Dictionary<int, int>();
 
        // Function call
        k_paths(root, k, p, 0);
 
        // Return the required answer
        return res;
    }
 
    // Driver code
    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;
        Console.WriteLine("No of paths with sum " +
                          "equals to {0} are: {1}", k,
                          printCount(root, k));
    }
}
//This code is contributed by Potta Lokesh




<script>
 
// Javascript program to print all root to leaf
// paths with there relative position
let res;
 
// Tree structure
class 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 map
function 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 differs
        // 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 k
function 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 code
res = 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>

Output
No of paths with sum equals to 3 are : 4

Time Complexity: O(N), where N is the number of nodes in the tree
Space Complexity: O(N), where N is the number of nodes in the tree 


Article Tags :