Updated 4 solutions

Author: RodneyShag

Chp. 04 - Trees and Graphs/_4_12_Paths_with_Sum/PathWithSums.java

@@ -1,50 +1,35 @@
 package _4_12_Paths_with_Sum;
 
-import java.util.ArrayList;
 import common.TreeNode;
+import java.util.*;
 
-// The Big Trick
-//
-// Instead of checking if a node starts a path that sums to "value", we check if it ENDS a path summing to "value".
 
 public class PathWithSums {
-    public static void findSum(TreeNode node, int value) {
-        findSum(node, value, new ArrayList<TreeNode>());
+    public static int findSum(TreeNode node, int targetSum) {
+        Map<Integer, Integer> map = new HashMap<>();
+        map.put(0, 1);
+        return findSum(node, targetSum, 0, map);
     }
 
-    /* Recursive function */
-    private static void findSum(TreeNode node, int value, ArrayList<TreeNode> path) {
+    private static int findSum(TreeNode node, int targetSum, int runningSum, Map<Integer, Integer> map) {
         if (node == null) {
-            return;
+            return 0;
         }
-        path.add(node);
-        checkSums(path, value);
-        findSum(node.left, value, path);
-        findSum(node.right, value, path);
-        path.remove(node); // We have 1 "remove" for each 1 "add"
-    }
 
-    /* We sum paths in REVERSE order to see if they equal 'value' */
-    private static void checkSums(ArrayList<TreeNode> path, int value) {
-        int sum = 0;
-        for (int i = path.size() - 1; i >= 0; i--) { // We must loop backwards
-            sum += path.get(i).data;
-            if (sum == value) {
-                printPath(path, i, path.size() - 1);
-            }
-        }
-    }
+        runningSum += node.data;
+        int totalPaths = map.getOrDefault(runningSum - targetSum, 0);
 
-    private static void printPath(ArrayList<TreeNode> path, int start, int end) {
-        System.out.println();
-        for (int i = start; i <= end; i++) {
-            System.out.print(path.get(i).data + " ");
+        map.merge(runningSum, 1, Integer::sum);
+        totalPaths += findSum(node.left, targetSum, runningSum, map);
+        totalPaths += findSum(node.right, targetSum, runningSum, map);
+        map.merge(runningSum, -1, Integer::sum);
+        if (map.get(runningSum) == 0) { // Remove when 0 to reduce space usage
+            map.remove(runningSum);
         }
+
+        return totalPaths;
     }
 }
 
-// Time/Space complexities: Assuming BALANCED binary tree
-// Time complexity: O(n log(n)) since we touch all "n" nodes, and findSum is O(log n)) in AVERAGE case.
-//                  findSum worst case is O((log n)^2) since it may call print every single time,
-//                  making overall time complexity worst case O(n (log n)^2)
-// Space complexity: O(log n) since that's the max size of a path, and also the max amount of recursive calls on stack.
+// Time Complexity: O(n)
+// Space Complexity: O(log n) on balanced tree. O(n) otherwise.

Chp. 04 - Trees and Graphs/_4_12_Paths_with_Sum/Tester.java

@@ -7,6 +7,7 @@ public class Tester {
     public static void main(String[] args) {
         System.out.print("*** Test 4.12: Paths with Sum\n");
         TreeNode tree = TreeFunctions.createBST();
-        PathWithSums.findSum(tree, 6);
+        int result = PathWithSums.findSum(tree, 6);
+        System.out.println(result);
     }
 }

Chp. 08 - Recursion and Dynamic Programming/_8_02_Robot_in_a_Grid/Point.java

@@ -1,6 +1,5 @@
 package _8_02_Robot_in_a_Grid;
 
-/* Used in 9.2 */
 public class Point {
     public int x;
     public int y;
@@ -14,11 +13,9 @@ public class Point {
     // http://javarevisited.blogspot.com/2011/02/how-to-write-equals-method-in-java.html
     // http://javarevisited.blogspot.com/2011/10/override-hashcode-in-java-example.html
 
-    /* Here for 9.2 to work with hashing Points */
     @Override
-    public boolean equals(Object other) { // must take an "Object" as a
-                                          // parameter, not a "Point", so that
-                                          // it overrides the .equals method
+    public boolean equals(Object other) { // must take an "Object" as a parameter, not a
+                                          // "Point", so that it overrides the .equals method
         if (other == this) {
             return true;
         } else if (other == null || !(other instanceof Point)) {

Chp. 08 - Recursion and Dynamic Programming/_8_02_Robot_in_a_Grid/RobotInAGrid.java

@@ -1,7 +1,6 @@
 package _8_02_Robot_in_a_Grid;
 
-import java.util.ArrayList;
-import java.util.HashMap;
+import java.util.*;
 
 public class RobotInAGrid {
 
@@ -80,38 +79,36 @@ private static boolean isFree(boolean[][] maze, int row, int col) {
     /* Follow-up (from website): Find ALL Paths */
     /********************************************/
     // similar to 8-Queens Problem.
-    // I search from end to start (makes code simpler to write)
     // no point in caching results since we have to try all paths
-    public static ArrayList<ArrayList<Point>> allPaths(boolean[][] maze, int row, int col) {
+    public static List<List<Point>> allPaths(boolean[][] maze, int row, int col) {
         if (maze == null || row >= maze.length || col >= maze[0].length) {
             return null;
         }
-        ArrayList<Point> path = new ArrayList<Point>();
-        ArrayList<ArrayList<Point>> solutionPaths = new ArrayList<ArrayList<Point>>();
-        getAllPaths(maze, row, col, path, solutionPaths);
+        List<List<Point>> solutionPaths = new ArrayList<>();
+        getAllPaths(maze, 0, 0, solutionPaths, new ArrayList<>());
         return solutionPaths;
     }
 
-    public static void getAllPaths(boolean[][] maze, int row, int col, ArrayList<Point> path, ArrayList<ArrayList<Point>> solutionPaths) {
+    public static void getAllPaths(boolean[][] maze, int row, int col, List<List<Point>> solutionPaths, List<Point> path) {
         if (!isFree(maze, row, col)) {
             return;
         }
         Point p = new Point(col, row);
         path.add(p);
-        if (row == 0 && col == 0) {
+        if (row == maze.length - 1 && col == maze[0].length - 1) {
             // Shallow copy would give us the correct solution too but each ArrayList<Point> in solutionPaths would
             // contain Points that are references to other Points in a different ArrayList<Point> in solutionsPaths
             deepCopyPathIntoSolutions(path, solutionPaths);
             // we do not add a "return" here so that the code will eventually get to "path.remove(p)"
         }
-        getAllPaths(maze, row, col - 1, path, solutionPaths);
-        getAllPaths(maze, row - 1, col, path, solutionPaths);
+        getAllPaths(maze, row, col + 1, solutionPaths, path);
+        getAllPaths(maze, row + 1, col, solutionPaths, path);
         path.remove(p); // notice there is exactly 1 .remove() since we had exactly 1 .add()
     }
 
-    private static void deepCopyPathIntoSolutions(ArrayList<Point> path, ArrayList<ArrayList<Point>> solutionPaths) {
-        ArrayList<Point> solutionPath = new ArrayList<>();
-        for (int i = path.size() - 1; i >= 0; i--) { // I reverse the order of the path here since we stored it backwards
+    private static void deepCopyPathIntoSolutions(List<Point> path, List<List<Point>> solutionPaths) {
+        List<Point> solutionPath = new ArrayList<>();
+        for (int i = 0; i < path.size(); i++) {
             Point point = path.get(i);
             solutionPath.add(new Point(point.x, point.y));
         }

Chp. 08 - Recursion and Dynamic Programming/_8_02_Robot_in_a_Grid/Tester.java

@@ -1,6 +1,6 @@
 package _8_02_Robot_in_a_Grid;
 
-import java.util.ArrayList;
+import java.util.*;
 
 public class Tester {
     public static void main(String[] args) {
@@ -28,7 +28,7 @@ private static void test_FindOnePath() {
     private static void test_FindAllPaths() {
         System.out.println("\n\n\n*** Test Follow-up: Find All Paths\n");
         boolean[][] maze = createMaze(3, 3);
-        ArrayList<ArrayList<Point>> solutionPaths = RobotInAGrid.allPaths(maze, 2, 2);
+        List<List<Point>> solutionPaths = RobotInAGrid.allPaths(maze, 2, 2);
         printAllPaths(solutionPaths);
     }
 
@@ -42,9 +42,9 @@ private static boolean[][] createMaze(int rows, int cols) {
         return maze;
     }
 
-    private static void printAllPaths(ArrayList<ArrayList<Point>> solutionPaths) {
+    private static void printAllPaths(List<List<Point>> solutionPaths) {
         if (solutionPaths != null) {
-            for (ArrayList<Point> path : solutionPaths) {
+            for (List<Point> path : solutionPaths) {
                 System.out.println(path);
             }
         }

Chp. 16 - More Problems (Moderate)/_16_08_English_Int/EnglishInt.java

@@ -23,7 +23,7 @@ public static String numToString(int num) {
         int bigsIndex = 0;
         StringBuffer sb = new StringBuffer();
 
-        // We create the string from right to left, inserting in the front. This makes code clean and scalability easier
+        // Create the string from right to left, inserting in the front.
         while (num > 0) {
             if (num % 1000 != 0) {
                 sb.insert(0, numToString100(num % 1000) + bigs[bigsIndex] + " ");

Chp. 17 - More Problems (Hard)/_17_20_Continuous_Median/ContinuousMedian.java

@@ -4,31 +4,25 @@
 import java.util.PriorityQueue;
 
 //- We use 2 Heaps to keep track of median
+//  - maxHeap contains all SMALL elements
+//  - minHeap contains all LARGE elements
 //- We make sure that 1 of the following conditions is always true:
 //   1) maxHeap.size() == minHeap.size()
 //   2) maxHeap.size() - 1 = minHeap.size()
 
 public class ContinuousMedian {
-    private static PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder()); // maxHeap contains all SMALL elements
-    private static PriorityQueue<Integer> minHeap = new PriorityQueue<>();                           // minHeap contains all LARGE elements
+    private static PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
+    private static PriorityQueue<Integer> minHeap = new PriorityQueue<>();
 
     public static void addNum(int n) {
         if (maxHeap.isEmpty()) {
             maxHeap.add(n);
         } else if (maxHeap.size() == minHeap.size()) {
-            if (n < minHeap.peek()) {
-                maxHeap.add(n);
-            } else {
-                minHeap.add(n);
-                maxHeap.add(minHeap.remove());
-            }
+            minHeap.add(n);
+            maxHeap.add(minHeap.remove());
         } else if (maxHeap.size() > minHeap.size()) {
-            if (n > maxHeap.peek()) {
-                minHeap.add(n);
-            } else {
-                maxHeap.add(n);
-                minHeap.add(maxHeap.remove());
-            }
+            maxHeap.add(n);
+            minHeap.add(maxHeap.remove());
         }
         // maxHeap will never be smaller size than minHeap
     }