practice

Author: metanet

src/problems/leetcode/BinaryTreeMaxPathSum.java

@@ -35,7 +35,8 @@ private static int traverse(TreeNode node) {
             return 0;
         }
 
-        int leftSum = traverse(node.left), rightSum = traverse(node.right);
+        int leftSum = traverse(node.left);
+        int rightSum = traverse(node.right);
         // this node only, this node with left sum, this node with right sum
         int maxChildSum = Math.max(node.val, node.val + Math.max(leftSum, rightSum));
         maxSum = Math.max(maxChildSum, maxSum);

src/problems/leetcode/PopulatingNextRightPointersInEachNode.java

@@ -37,28 +37,35 @@ public String toString() {
         }
     }
 
-    private List<Node> prevs = new ArrayList<>();
-
+    // runtime: O(N)
+    // space: O(N/2) which is actually O(N). N/2 is the number of nodes in the leaf level.
     public Node connect(Node root) {
-        connect(root, 1);
-        return root;
-    }
-
-    private void connect(Node node, int level) {
-        if (node == null) {
-            return;
+        if (root == null) {
+            return null;
         }
 
-        if (prevs.size() < level) {
-            prevs.add(node);
-        } else {
-            Node prev = prevs.get(level - 1);
-            prev.next = node;
-            prevs.set(level - 1, node);
+        List<Node> nodes = new ArrayList<>();
+        nodes.add(root);
+
+        while (nodes.size() > 0) {
+            Node prev = null;
+            List<Node> nextLevel = new ArrayList<>();
+            for (Node node : nodes) {
+                if (node.left != null) {
+                    nextLevel.add(node.left);
+                }
+                if (node.right != null) {
+                    nextLevel.add(node.right);
+                }
+                if (prev != null) {
+                    prev.next = node;
+                } 
+                prev = node;
+            }
+            nodes = nextLevel;
         }
 
-        connect(node.left, level + 1);
-        connect(node.right, level + 1);
+        return root;        
     }
 
     public static void main(String[] args) {

src/problems/leetcode/PopulatingNextRightPointersInEachNodeII.java

@@ -0,0 +1,84 @@
+package problems.leetcode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * https://leetcode.com/problems/populating-next-right-pointers-in-each-node-ii/submissions/
+ */
+public class PopulatingNextRightPointersInEachNodeII {
+
+    private static class Node {
+        public int val;
+        public Node left;
+        public Node right;
+        public Node next;
+
+        public Node() {
+        }
+
+        public Node(int val) {
+            this.val = val;
+        }
+
+        public Node(int _val, Node _left, Node _right, Node _next) {
+            val = _val;
+            left = _left;
+            right = _right;
+            next = _next;
+        }
+
+        @Override
+        public String toString() {
+            return "Node{" +
+                    "val=" + val +
+                    ", next=" + next +
+                    '}';
+        }
+    }
+
+    // runtime: O(N)
+    // space: O(N/2) which is actually O(N). N/2 is the number of nodes in the leaf level.
+    public Node connect(Node root) {
+        if (root == null) {
+            return null;
+        }
+
+        List<Node> nodes = new ArrayList<>();
+        nodes.add(root);
+
+        while (nodes.size() > 0) {
+            Node prev = null;
+            List<Node> nextLevel = new ArrayList<>();
+            for (Node node : nodes) {
+                if (node.left != null) {
+                    nextLevel.add(node.left);
+                }
+                if (node.right != null) {
+                    nextLevel.add(node.right);
+                }
+                if (prev != null) {
+                    prev.next = node;
+                } 
+                prev = node;
+            }
+            nodes = nextLevel;
+        }
+
+        return root;        
+    }
+
+    public static void main(String[] args) {
+        Node root = new Node(1);
+        root.left = new Node(2);
+        root.right = new Node(3);
+        root.left.left = new Node(4);
+        root.left.right = new Node(5);
+        root.right.left = new Node(6);
+        root.right.right = new Node(7);
+
+        Node newRoot = new PopulatingNextRightPointersInEachNode().connect(root);
+        System.out.println();
+    }
+
+}

src/problems/leetcode/SumRootToLeafNumbers.java

@@ -0,0 +1,43 @@
+package problems.leetcode;
+
+// https://leetcode.com/problems/sum-root-to-leaf-numbers/
+public class SumRootToLeafNumbers {
+    
+    private static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+
+        TreeNode(int x) {
+            val = x;
+        }
+
+        @Override
+        public String toString() {
+            return "TreeNode{" + "val=" + val + '}';
+        }
+    }
+
+    private int sum;
+
+    // runtime: O(N)
+    // space: O(H)
+    public int sumNumbers(TreeNode root) {
+        sumNumbers(root, 0);
+        return sum;
+    }
+
+    private void sumNumbers(TreeNode root, int parent) {
+        if (root == null) {
+            return;
+        } 
+        
+        int num = parent * 10 + root.val;
+        if (root.left == null && root.right == null) {
+            sum += num;   
+        }
+
+        sumNumbers(root.left, num);
+        sumNumbers(root.right, num);
+    }
+}

src/problems/leetcode/TimeNeededToInformAllEmployees.java

@@ -0,0 +1,39 @@
+package problems.leetcode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+// https://leetcode.com/problems/time-needed-to-inform-all-employees/editorial/
+public class TimeNeededToInformAllEmployees {
+    int maxTime = Integer.MIN_VALUE;
+
+    void DFS(List<List<Integer>> adjList, int[] informTime, int curr, int time) {
+        // Maximum time for an employee to get the news.
+        maxTime = Math.max(maxTime, time);
+
+        for (int adjacent : adjList.get(curr)) {
+            // Visit the subordinate employee who gets the news after informTime[curr] unit
+            // time.
+            DFS(adjList, informTime, adjacent, time + informTime[curr]);
+        }
+    }
+
+    public int numOfMinutes(int n, int headID, int[] manager, int[] informTime) {
+        List<List<Integer>> adjList = new ArrayList<>(n);
+
+        for (int i = 0; i < n; i++) {
+            adjList.add(new ArrayList<Integer>());
+        }
+
+        // Making an adjacent list, each index stores the Ids of subordinate employees.
+        for (int i = 0; i < n; i++) {
+            if (manager[i] != -1) {
+                adjList.get(manager[i]).add(i);
+            }
+        }
+
+        DFS(adjList, informTime, headID, 0);
+        return maxTime;
+    }
+
+}