437. Path Sum III

Author: a-khakimov

leetcode-scala/src/main/scala/LeetCode75/BinaryTree_DFS/112. Path Sum.sc

@@ -0,0 +1,49 @@
+
+
+class TreeNode(_value: Int = 0, _left: TreeNode = null, _right: TreeNode = null) {
+  var value: Int = _value
+  var left: TreeNode = _left
+  var right: TreeNode = _right
+}
+
+object Solution {
+  def hasPathSum(root: TreeNode, targetSum: Int): Boolean = {
+    def dfs(node: TreeNode, sum: Int): Boolean = {
+      if (node == null) false else {
+        val newSum = sum - node.value
+        if (newSum == 0 && node.right == null && node.left == null) true
+        else dfs(node.left, newSum) || dfs(node.right, newSum)
+      }
+    }
+    dfs(root, targetSum)
+  }
+}
+
+val tree1 = new TreeNode(5,
+  new TreeNode(4,
+    new TreeNode(11,
+      new TreeNode(7),
+      new TreeNode(2)
+    )
+  ),
+  new TreeNode(8,
+    new TreeNode(4),
+    new TreeNode(2,
+      new TreeNode(9),
+      new TreeNode(11,
+        new TreeNode(8),
+        new TreeNode(10)
+      )
+    )
+  )
+)
+
+val tree2 =  new TreeNode(1, new TreeNode(2))
+
+val tree3 =  new TreeNode(1, new TreeNode(2), new TreeNode(3))
+
+Solution.hasPathSum(tree1, 22) // true
+Solution.hasPathSum(tree2, 1) // false
+Solution.hasPathSum(tree3, 5) // false
+
+

leetcode-scala/src/main/scala/LeetCode75/BinaryTree_DFS/113. Path Sum II.sc

@@ -0,0 +1,50 @@
+
+
+class TreeNode(_value: Int = 0, _left: TreeNode = null, _right: TreeNode = null) {
+  var value: Int = _value
+  var left: TreeNode = _left
+  var right: TreeNode = _right
+}
+
+object Solution {
+  def pathSum(root: TreeNode, targetSum: Int): List[List[Int]] = {
+    var result: List[List[Int]] = Nil
+    def dfs(node: TreeNode, sum: Int, acc: List[Int]): Unit = {
+      if (node != null) {
+        val newSum = sum - node.value
+        if (newSum == 0 && node.right == null && node.left == null) {
+          result = (node.value :: acc) :: result
+        } else {
+          dfs(node.right, newSum, node.value :: acc)
+          dfs(node.left, newSum, node.value :: acc)
+        }
+      }
+    }
+    dfs(root, targetSum, Nil)
+    result.map(_.reverse)
+  }
+}
+
+val tree1 = new TreeNode(5,
+  new TreeNode(4,
+    new TreeNode(11,
+      new TreeNode(7),
+      new TreeNode(2)
+    )
+  ),
+  new TreeNode(8,
+    new TreeNode(13),
+    new TreeNode(4,
+      new TreeNode(5),
+      new TreeNode(1)
+    )
+  )
+)
+
+val tree2 =  new TreeNode(1, new TreeNode(2))
+
+val tree3 =  new TreeNode(1, new TreeNode(2), new TreeNode(3))
+
+Solution.pathSum(tree1, 22) // List(List(5, 4, 11, 2), List(5, 8, 4, 5))
+Solution.pathSum(tree2, 1)  // Nil
+Solution.pathSum(tree3, 5)  // Nil

leetcode-scala/src/main/scala/LeetCode75/BinaryTree_DFS/437. Path Sum III.sc

@@ -0,0 +1,76 @@
+
+
+class TreeNode(_value: Int = 0, _left: TreeNode = null, _right: TreeNode = null) {
+  var value: Int = _value
+  var left: TreeNode = _left
+  var right: TreeNode = _right
+}
+
+object Solution {
+  def pathSum(root: TreeNode, targetSum: Int): Int = {
+    var result = 0
+    def dfs(node: TreeNode, tail: List[Int]): Unit = {
+      if (node != null) {
+        val path = node.value :: tail
+        val len = path.length
+        var sum: Long = 0
+        var i = 0
+        while (i < len) {
+          sum += path(i)
+          if (sum == targetSum) {
+            result += 1
+          }
+          i += 1
+        }
+        if (node.right != null || node.left != null) {
+          dfs(node.right, path)
+          dfs(node.left, path)
+        }
+      }
+    }
+    dfs(root, Nil)
+    result
+  }
+}
+
+val tree1 = new TreeNode(10,
+  new TreeNode(5,
+    new TreeNode(3,
+      new TreeNode(3),
+      new TreeNode(-2)
+    ),
+    new TreeNode(2,
+      new TreeNode(1)
+    )
+  ),
+  new TreeNode(-3, new TreeNode(11))
+)
+
+val tree2 =  new TreeNode(1, new TreeNode(2))
+val tree3 =  new TreeNode(1, new TreeNode(2), new TreeNode(3))
+val tree4 =  new TreeNode(1)
+val tree5 =  new TreeNode(
+  1000000000,
+  new TreeNode(
+    1000000000,
+    new TreeNode(
+      294967296,
+      new TreeNode(
+        1000000000,
+        new TreeNode(
+          1000000000,
+          new TreeNode(
+            1000000000
+          )
+        )
+      )
+    )
+  )
+)
+
+
+Solution.pathSum(tree1, 8) // 3
+Solution.pathSum(tree2, 1) // 1
+Solution.pathSum(tree3, 1) // 1
+Solution.pathSum(tree4, 1) // 1
+Solution.pathSum(tree5, 0) // 0