Skip to content
Related Articles

Related Articles

Shortest root to leaf path sum equal to a given number
  • Difficulty Level : Medium
  • Last Updated : 08 Jul, 2019

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++




// 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;
}

Java




// 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

Python3




# 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) 

C#




// 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
Output:
There is a root-to-leaf path with sum 16
and the shortest path length is: 1

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up
Recommended Articles
Page :