LeetCode question Path Sum II: Recursive solution bug - go

Question

I have submitted the below solution for the question in golang and it fails for the base case. I am not able to figure out why it is failing.
var answer[][]int
func hasPathSum(root *TreeNode, sum int, path []int){
if root == nil {
return
}
newPath := append(path, root.Val)
sum = sum - root.Val
if root.Left == nil && root.Right == nil && sum == 0 {
answer = append(answer, newPath)
fmt.Println(answer)
return
}
if root.Left != nil {
hasPathSum(root.Left, sum, newPath)
}
if root.Right != nil {
hasPathSum(root.Right, sum, newPath)
}
}
func pathSum(root *TreeNode, sum int) [][]int {
var path []int
answer = [][]int{}
hasPathSum(root, sum, path)
return answer
}
And when I avoid declaring newPath it passes the base check. Like this:
var answer[][]int
func hasPathSum(root *TreeNode, sum int, path []int){
if root == nil {
return
}
sum = sum - root.Val
if root.Left == nil && root.Right == nil && sum == 0 {
answer = append(answer, append(path, root.Val))
fmt.Println(answer)
return
}
if root.Left != nil {
hasPathSum(root.Left, sum, append(path, root.Val))
}
if root.Right != nil {
hasPathSum(root.Right, sum, append(path, root.Val))
}
}
func pathSum(root *TreeNode, sum int) [][]int {
var path []int
answer = [][]int{}
hasPathSum(root, sum, path)
return answer
}
I am not able to figure out what is the difference between the two solutions. Both solutions are the same from the recursion point of view. Furthermore, a similar solution in C++ passes all the checks.

Answer 1

The problem occurs because slices refer to an underlying array, and append does not re-allocate a new array if there's space. See https://blog.golang.org/slices-intro
That means when you append(path, root.Val), the new slice will sometimes share the backing array with path. That can be a problem, for example:
if root.Left != nil {
hasPathSum(root.Left, sum, append(path, root.Val))
}
if root.Right != nil {
hasPathSum(root.Right, sum, append(path, root.Val))
}
Here, both branches may be using the same backing array. That's a problem, because when executing the first hasPathSum it may add a slice to answer, but the underlying array of that slice may still be used in the second call to hasPathSum, which will change its contents.
Both versions of the code have the same problem, but because the second is less likely to cause problems because if append(path, root.Val) needs to reallocate, then you get two different copies in the two branches of hasPathSum. This means the bug will happen at a lower frequency.

Answer 2

I'm not sure about fmt.Println(answer), you'd probably just need to return answer.
This'll pass:
func pathSum(root *TreeNode, sum int) [][]int {
var paths [][]int
if root == nil {
return paths
}
if root.Left == nil && root.Right == nil {
if sum == root.Val {
return append(paths, []int{ root.Val })
}
return paths
}
for _, path := range pathSum(root.Left, sum - root.Val) {
paths = append(paths, append([]int{ root.Val}, path... ))
}
for _, path := range pathSum(root.Right, sum - root.Val) {
paths = append(paths, append([]int{ root.Val}, path... ))
}
return paths
}
Here is LeetCode's Java solution with comments:
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
private void recurseTree(TreeNode node, int remainingSum, List<Integer> pathNodes, List<List<Integer>> pathsList) {
if (node == null) {
return;
}
// Add the current node to the path's list
pathNodes.add(node.val);
// Check if the current node is a leaf and also, if it
// equals our remaining sum. If it does, we add the path to
// our list of paths
if (remainingSum == node.val && node.left == null && node.right == null) {
pathsList.add(new ArrayList<>(pathNodes));
} else {
// Else, we will recurse on the left and the right children
this.recurseTree(node.left, remainingSum - node.val, pathNodes, pathsList);
this.recurseTree(node.right, remainingSum - node.val, pathNodes, pathsList);
}
// We need to pop the node once we are done processing ALL of it's
// subtrees.
pathNodes.remove(pathNodes.size() - 1);
}
public List<List<Integer>> pathSum(TreeNode root, int sum) {
List<List<Integer>> pathsList = new ArrayList<List<Integer>>();
List<Integer> pathNodes = new ArrayList<Integer>();
this.recurseTree(root, sum, pathNodes, pathsList);
return pathsList;
}
}
References
For additional details, you can see the Discussion Board. There are plenty of accepted solutions with a variety of languages and explanations, efficient algorithms, as well as asymptotic time/space complexity analysis1, 2 in there.