Finding Paths
Kevin has written some integers on a paper. He then selects some integers and draws a line between them. Fortunately, his diagram represents a binary tree. Today, his friend challenged him to find the paths that start from root and end at the leaf in his diagram whose sum is exactly equal to the number ‘K’. But, Kevin has another important piece of work and so, he appoints you to do his task.

All you have to do is to find the paths in his diagram whose sum is exactly equal to the number ‘K’.

For Example:

Consider the above binary tree. If ‘K’ is 15 then the required paths are [5, 6, 4] and [5, 15, -5].

Input Format :

The first line contains an integer 'T' which denotes the number of test cases or queries to be run. Then the test cases are as follows. The first line of each test case contains an integer ‘K’ which represents the number ‘K’. The second line of each test case contains elements of the tree in the level order form. The line consists of values of nodes separated by a single space. In case a node is null, we take -1 in its place. For example, the input for the tree depicted in the below image would be :

1 2 3 4 -1 5 6 -1 7 -1 -1 -1 -1 -1 -1

Explanation :

Level 1 : The root node of the tree is 1 Level 2 : Left child of 1 = 2 Right child of 1 = 3 Level 3 : Left child of 2 = 4 Right child of 2 = null (-1) Left child of 3 = 5 Right child of 3 = 6 Level 4 : Left child of 4 = null (-1) Right child of 4 = 7 Left child of 5 = null (-1) Right child of 5 = null (-1) Left child of 6 = null (-1) Right child of 6 = null (-1) Level 5 : Left child of 7 = null (-1) Right child of 7 = null (-1) The first not-null node(of the previous level) is treated as the parent of the first two nodes of the current level. The second not-null node (of the previous level) is treated as the parent node for the next two nodes of the current level and so on. The input ends when all nodes at the last level are null(-1).

Note :

The above format was just to provide clarity on how the input is formed for a given tree. The sequence will be put together in a single line separated by a single space. Hence, for the above-depicted tree, the input will be given as: 1 2 3 4 -1 5 6 -1 7 -1 -1 -1 -1 -1 -1

Output Format:

For each test case, return all the paths that start from the root and end at the leaf and whose sum is exactly equal to ‘K’. All the paths should be printed in a separate line and should be enclosed in a square bracket. Output for every test case will be printed in a separate line.

Note:

You don’t need to print anything; It has already been taken care of. Just implement the given function.

Constraints:

1

Question

Finding Paths

Kevin has written some integers on a paper. He then selects some integers and draws a line between them. Fortunately, his diagram represents a binary tree. Today, his friend challenged him to find the paths that start from root and end at the leaf in his diagram whose sum is exactly equal to the number ‘K’. But, Kevin has another important piece of work and so, he appoints you to do his task.

All you have to do is to find the paths in his diagram whose sum is exactly equal to the number ‘K’.

For Example:

Example

Consider the above binary tree. If ‘K’ is 15 then the required paths are [5, 6, 4] and [5, 15, -5].

Input Format :

The first line contains an integer 'T' which denotes the number of test cases or queries to be run. Then the test cases are as follows.

The first line of each test case contains an integer ‘K’ which represents the number ‘K’.

The second line of each test case contains elements of the tree in the level order form. The line consists of values of nodes separated by a single space. In case a node is null, we take -1 in its place.

For example, the input for the tree depicted in the below image would be :

Example

1
2 3
4 -1 5 6
-1 7 -1 -1 -1 -1
-1 -1

Explanation :

Level 1 :
The root node of the tree is 1

Level 2 :
Left child of 1 = 2
Right child of 1 = 3

Level 3 :
Left child of 2 = 4
Right child of 2 = null (-1)
Left child of 3 = 5
Right child of 3 = 6

Level 4 :
Left child of 4 = null (-1)
Right child of 4 = 7
Left child of 5 = null (-1)
Right child of 5 = null (-1)
Left child of 6 = null (-1)
Right child of 6 = null (-1)

Level 5 :
Left child of 7 = null (-1)
Right child of 7 = null (-1)

The first not-null node(of the previous level) is treated as the parent of the first two nodes of the current level. The second not-null node (of the previous level) is treated as the parent node for the next two nodes of the current level and so on.
The input ends when all nodes at the last level are null(-1).

Note :

The above format was just to provide clarity on how the input is formed for a given tree. 

The sequence will be put together in a single line separated by a single space. Hence, for the above-depicted tree, the input will be given as:

1 2 3 4 -1 5 6 -1 7 -1 -1 -1 -1 -1 -1

Output Format:

For each test case, return all the paths that start from the root and end at the leaf and whose sum is exactly equal to ‘K’. All the paths should be printed in a separate line and should be enclosed in a square bracket.

Output for every test case will be printed in a separate line.

Note:

You don’t need to print anything; It has already been taken care of. Just implement the given function.

Constraints:

1 <= T <= 10
1 <= N <= 10^3
-10^5 <= K <= 10^5
-10^5 <= DATA <= 10^4

Time limit: 1 sec

Accepted Answer

Depth First Search and Backtracking

The basic idea is to perform Depth First Search on the given binary Tree and keep track of the current sum and whenever reached the lead node check if the sum becomes equal to the ‘K’ then pick this path, otherwise just backtrack to the previous node and exclude the value of this leaf node from the current sum.

We are here using a helper function that is recursive in nature and is used to find all the required paths.

void helper(TreeNode *root, vector> &reqPaths, int K, vector curPath)

Where “ROOT” is the root node of the given binary tree, “REQ_PATHS” is the vector that holds all the required paths, ‘K’ is the number described in the question, and “CUR_PATH” is the vector that holds all the nodes which involved in the current path.

The steps are as follows:

In the “HELPER” function
- If “ROOT” is NULL then return.
- Add the value of the current node in “CUR_PATH”.
- Check if this is the leaf node and its value is equal to the ‘K’ then push “CUR_PATH” in “REQ_PATHS”.
- Call for the left subtree with arguments as “ROOT”, “REQ_PATHS”, ‘K’ - the value of the current node, and “CUR_PATH”.
- Similarly, make a call for the right subtree.
- Remove the value of the current node from the “CUR_PATH”.
In the given function
- Create a vector of vectors “REQ_PATHS” that holds all the required Paths.
- Check if the “ROOT” is NULL then return “REQ_PATHS”.
- Create a vector “CUR_PATH” that will be used to store the value of nodes that are involved in the current path.
- Call the “HELPER” function with arguments as “ROOT’, “REQ_PATHS”, ‘K’, and ‘’CUR_PATH”.
- Return “REQ_PATHS”.

Space Complexity: O(n)Explanation:

O(N), where ‘N’ is the total number of nodes in the given binary tree.

Since the height of the recursion tree goes up to ‘N’ nodes and so, the overall space complexity will be O(N).

Time Complexity: O(n^2)Explanation:

O(N^2), where ‘N’ is the total number of nodes in the given binary tree.

Since we are traversing each node of the binary tree once and for every valid path we are pushing each node into the vector “reqPaths” and so the overall time complexity will be O(N^2).

For the deep analysis, consider an example such that there is a bamboo of N/2 nodes (Each node has only a single child) and then a full binary tree with N/2 nodes ( having N/4 (lower bound) leaf nodes). Now, if all the paths are having a sum equal to ‘K’ then for each N/4 (lower bound) paths we are pushing (N/2) + (log(N/4)) nodes. And, it makes total time complexity equal to O(N^2).

C++ (g++ 5.4)

/*

	Time complexity: O(N^2) 

	Space complexity: O(N)

	

	Where ‘N’ is the number of nodes in the given binary tree.

*/



void helper(TreeNode *root, vector> &reqPaths, int k, vector &curPath)

{

    //  Return, If root is NULL.

    if (root == NULL)

    {

        return;

    }



    //  Add the value of the current node in “curPath”.

    curPath.push_back(root->data);



    //  Check if this is the leaf node and its value is equal to the ‘K’.

    if (root->left == NULL && root->right == NULL && root->data == k)

    {

        reqPaths.push_back(curPath);

    }



    //  Check required paths in the left subtrees and right subtrees.

    helper(root->left, reqPaths, k - root->data, curPath);

    helper(root->right, reqPaths, k - root->data, curPath);



    //  Remove the value of the current node from the “curPath”.

    curPath.pop_back();

}



vector> KSumPaths(TreeNode *root, int k)

{

    //  Vector to holds all the required Paths.

    vector> reqPaths;



    //  If, tree is empty then no ways are possible.

    if (root == NULL)

    {

        return reqPaths;

    }



    //  Vector to store the value of nodes that are involved in the current path.

    vector curPath;



    //  Call the helper function.

    helper(root, reqPaths, k, curPath);



    return reqPaths;

}

Java (SE 1.8)

/*
	Time complexity: O(N^2) 
	Space complexity: O(N)
	
	Where 'N' is the number of nodes in the given binary tree.
*/

import java.util.ArrayList;

public class Solution {

	private static void helper(TreeNode root, ArrayList> reqPaths, int k,
			ArrayList curPath) {
		// Return, If root is null.
		if (root == null) {
			return;
		}

		// .add the value of the current node in "curPath".
		curPath.add(root.data);

		// Check if this is the leaf node and its value is equal to the 'K'.
		if (root.left == null && root.right == null && root.data == k) {

			reqPaths.add(new ArrayList(curPath));
		}

		// Check required paths in the left subtrees and right subtrees.
		helper(root.left, reqPaths, k - root.data, curPath);
		helper(root.right, reqPaths, k - root.data, curPath);

		// Remove the value of the current node from the "curPath".
		curPath.remove(curPath.size() - 1);
	}

	public static ArrayList> KSumPaths(TreeNode root, int k) {
		// ArrayList to holds all the required Paths.
		ArrayList> reqPaths = new ArrayList>();

		// If, tree is empty then no ways are possible.
		if (root == null) {
			return reqPaths;
		}

		// ArrayList to store the value of nodes that are involved in the current path.
		ArrayList curPath = new ArrayList();

		// Call the helper function.
		helper(root, reqPaths, k, curPath);

		return reqPaths;
	}
}

Python (3.5)

'''
	Time complexity: O(N^2) 
	Space complexity: O(N)
	
	Where 'N' is the number of nodes in the given binary tree.
'''

def helper(root, reqPaths, k, curPath):
    
    # Return, If root is null.
    if root == None:
        return
    
    # Add the value of the current node in "curPath".
    curPath.append(root.data)
    
    # Check if this is the leaf node and its value is equal to the 'K'.
    if root.left == None and root.right == None and root.data == k:
        
        reqPaths.append(list(curPath))
        
    # Check required paths in the left subtrees and right subtrees.
    helper(root.left, reqPaths, k - root.data, curPath)
    helper(root.right, reqPaths, k - root.data, curPath)
    
    # Remove the value of the current node from the 'curPath'.
    curPath.pop()
    

def KSumPaths(root, k):
    # ArrayList to holds all the required Paths.
    reqPaths = []
    
    # If, tree is empty then no ways are possible.
    if root == None:
        return reqPaths
        
    # ArrayList to store the value of nodes that are involved in the current path.
    curPath = []
    
    # Call the helper function.
    helper(root, reqPaths, k, curPath)
    
    return reqPaths