Shortest root to leaf path sum equal to a given number

Given a binary tree and a number, the task is to return the length of the shortest path beginning at root and ending at a leaf node such that the sum of numbers along that path is equal to ‘sum’. Print “-1” if no such path exists.

Examples:

Input: 
                 1
             /       \ 
          10         15 
       /      \     
     5        2 
Number = 16 
Output: 2 

There are two paths: 
1->15, length of path is 3
1->10->5, length of path is 2 

Input:
                 1
             /       \ 
          10         15 
       /      \     
     5        2 
Number = 20
Output: -1 
There exists no such path with 20 as sum from root to any node 

Source: Microsoft Interview



Approach: An approach to check whether such a path exists or not has been discussed in this post. The below steps can be followed to find the shortest path.

  • Recursively call the left and right child with path sum and level to ( number – value at the current node, level+1).
  • If the leaf node is reached, then store the minimum of all the levels of the leaf node.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
  
/* A binary tree node has data, pointer to left child 
and a pointer to right child */
struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};
  
// Function to find the shortes path from root
// to leaf with given sum
void hasPathSum(struct Node* node, int sum,
                int& mini, int level)
{
    // went beyond tree
    if (node == NULL)
        return;
    int subSum = sum - (node->data);
    if (node->left == NULL && node->right == NULL) {
        // Store the minimum path
        if (subSum == 0)
            mini = min(level - 1, mini);
        return;
    }
  
    else {
        // Recur in the left tree
        hasPathSum(node->left, subSum, mini, level + 1);
  
        // Recur in the right tree
        hasPathSum(node->right, subSum, mini, level + 1);
    }
}
  
/* UTILITY FUNCTIONS */
/* Helper function that allocates a new node with the 
given data and NULL left and right pointers. */
struct Node* newnode(int data)
{
    struct Node* node = new Node;
    node->data = data;
    node->left = NULL;
    node->right = NULL;
  
    return (node);
}
  
/* Driver program to test above functions*/
int main()
{
  
    int sum = 16;
  
    /* Constructed binary tree is 
          
                 1
             /       \ 
          10         15 
       /      \     
     5        2 
*/
    struct Node* root = newnode(1);
    root->left = newnode(10);
    root->right = newnode(15);
    root->left->left = newnode(5);
    root->left->right = newnode(2);
  
    int mini = INT_MAX;
  
    // Function call
    hasPathSum(root, sum, mini, 0);
  
    if (mini != INT_MAX)
        printf("There is a root-to-leaf path with sum %d\n"
               "and the shortest path length is: %d",
               sum, mini + 1);
    else
        printf("There is no root-to-leaf path with sum %d", sum);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the above approach 
class GFG 
{
  
static int mini;
  
/* A binary tree node has data, pointer to left child 
and a pointer to right child */
static class Node
    int data; 
    Node left; 
    Node right; 
}; 
  
// Function to find the shortes path from root 
// to leaf with given sum 
static void hasPathSum(Node node, int sum, 
                int level) 
    // went beyond tree 
    if (node == null
        return
    int subSum = sum - (node.data); 
    if (node.left == null && node.right == null
    
        // Store the minimum path 
        if (subSum == 0
            mini = Math.min(level - 1, mini); 
        return
    
  
    else 
    
        // Recur in the left tree 
        hasPathSum(node.left, subSum, level + 1); 
  
        // Recur in the right tree 
        hasPathSum(node.right, subSum, level + 1); 
    
  
/* UTILITY FUNCTIONS */
/* Helper function that allocates a new node with the 
given data and null left and right pointers. */
static Node newnode(int data) 
    Node node = new Node(); 
    node.data = data; 
    node.left = null
    node.right = null
  
    return (node); 
  
/* Driver code*/
public static void main(String[] args)
{
    int sum = 16
  
    /* Constructed binary tree is 
          
                
            / \ 
        10     15 
    / \ 
    5 2 
*/
    Node root = newnode(1); 
    root.left = newnode(10); 
    root.right = newnode(15); 
    root.left.left = newnode(5); 
    root.left.right = newnode(2); 
  
    mini = Integer.MAX_VALUE; 
  
    // Function call 
    hasPathSum(root, sum, 0); 
  
    if (mini != Integer.MAX_VALUE) 
        System.out.printf("There is a root-to-leaf path with sum %d\n"
            +"and the shortest path length is: %d"
                        ,sum, mini + 1); 
    else
        System.out.printf("There is no root-to-leaf path with sum %d", sum);
  
    }
}
  
// This code is contributed by Princi Singh

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the above approach 
  
INT_MAX = 2147483647
  
""" A binary tree node has data, pointer 
to left child and a pointer to right child """
  
"""UTILITY FUNCTIONS 
Helper function that allocates a new node 
with the given data and NULL left and right 
pointers."""
class newnode: 
  
    # Construct to create a newNode 
    def __init__(self, key): 
        self.data = key 
        self.left = None
        self.right = None
  
# Function to find the shortes path 
# from root to leaf with given summ 
def hasPathSum(node, summ, mini, level) : 
  
    # check if leaf node and check summ 
    if (node == None) : 
        return
    subsumm = summ - node.data
      
    if(node.left == None and node.right == None): 
        # Store the minimum path 
        if (subsumm == 0) : 
            mini[0] = min(level - 1, mini[0]) 
        return
      
    else
          
  
        # Recur in the left tree 
        hasPathSum(node.left, subsumm, 
                    mini, level + 1
  
        # Recur in the right tree 
        hasPathSum(node.right, subsumm, 
                    mini, level + 1
      
# Driver Code 
if __name__ == '__main__'
  
    summ = 16
  
    """ Constructed binary tree is 
          
                
            /     \ 
        10         15 
          
    /     \           \
    5     2         15
    """
    root = newnode(1
    root.left = newnode(10
    root.right = newnode(15)
    root.left.left = newnode(5
    root.left.right = newnode(2
  
    mini = [INT_MAX] 
  
    # Function call 
    hasPathSum(root, summ, mini, 0
  
    if (mini[0] != INT_MAX) : 
        print("There is a root-to-leaf path"
                        "with sum", summ) 
        print("and the shortest path length is:"
                                        mini[0] + 1
    else
        print("There is no root-to-leaf path"
                            "with sum ", summ) 
  
# This code is contributed by 
# Shubham Singh(SHUBHAMSINGH10) 

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the above approach
using System;
      
class GFG 
{
  
static int mini;
  
/* A binary tree node has data, pointer to left child 
and a pointer to right child */
public class Node
    public int data; 
    public Node left; 
    public Node right; 
}; 
  
// Function to find the shortes path from root 
// to leaf with given sum 
static void hasPathSum(Node node, int sum, 
                int level) 
    // went beyond tree 
    if (node == null
        return
    int subSum = sum - (node.data); 
    if (node.left == null && node.right == null
    
        // Store the minimum path 
        if (subSum == 0) 
            mini = Math.Min(level - 1, mini); 
        return
    
  
    else
    
        // Recur in the left tree 
        hasPathSum(node.left, subSum, level + 1); 
  
        // Recur in the right tree 
        hasPathSum(node.right, subSum, level + 1); 
    
  
/* UTILITY FUNCTIONS */
/* Helper function that allocates a new node with the 
given data and null left and right pointers. */
static Node newnode(int data) 
    Node node = new Node(); 
    node.data = data; 
    node.left = null
    node.right = null
  
    return (node); 
  
/* Driver code*/
public static void Main(String[] args)
{
    int sum = 16; 
  
    /* Constructed binary tree is 
          
                
            / \ 
        10     15 
    / \ 
    5 2 
*/
    Node root = newnode(1); 
    root.left = newnode(10); 
    root.right = newnode(15); 
    root.left.left = newnode(5); 
    root.left.right = newnode(2); 
  
    mini = int.MaxValue; 
  
    // Function call 
    hasPathSum(root, sum, 0); 
  
    if (mini != int.MaxValue) 
        Console.Write("There is a root-to-leaf path with sum {0}\n"
            +"and the shortest path length is: {1}"
                        ,sum, mini + 1); 
    else
        Console.Write("There is no root-to-leaf path with sum {0}", sum);
  
    }
}
  
// This code is contributed by Rajput-Ji

chevron_right


Output:

There is a root-to-leaf path with sum 16
and the shortest path length is: 1


My Personal Notes arrow_drop_up

Striver(underscore)79 at Codechef and codeforces D

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.





Article Tags :
Practice Tags :


1


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.