Added comments, runtime, etc.

Author: rampatra

src/main/java/com/leetcode/arrays/NestedListWeightSumII.java

@@ -28,30 +28,31 @@
 public class NestedListWeightSumII {
 
     /**
+     * Time Complexity:
+     * Space Complexity:
+     * Runtime: <a href="https://leetcode.com/submissions/detail/248595263/">1 ms</a>.
+     *
      * @param nestedList
      * @return
      */
-    public static long nestedSum(List<NestedInteger> nestedList) {
-        long weightedSum = 0;
-        long unweightedSum = 0;
-        Queue<NestedInteger> queue = new LinkedList<>();
-
-        for (NestedInteger nestedInteger : nestedList) {
-            if (nestedInteger.isInteger()) {
-                unweightedSum += nestedInteger.getInteger();
-            } else {
-                queue.addAll(nestedInteger.getList());
-                while (!queue.isEmpty()) {
-                    NestedInteger ni = queue.poll();
-                    if (ni.isInteger()) {
-                        unweightedSum += ni.getInteger();
-                    } else {
-                        nestedList.addAll(ni.getList());
-                    }
+    public static int nestedSum(List<NestedInteger> nestedList) {
+        int weightedSum = 0;
+        int unweightedSum = 0;
+
+        while (!nestedList.isEmpty()) {
+            List<NestedInteger> nextLevel = new ArrayList<>();
+
+            for (NestedInteger ni : nestedList) {
+                if (ni.isInteger()) {
+                    unweightedSum += ni.getInteger();
+                } else {
+                    nextLevel.addAll(ni.getList());
                 }
-                unweightedSum += unweightedSum;
-                weightedSum = unweightedSum;
             }
+
+            unweightedSum += unweightedSum; // multiplication by repetitive addition
+            weightedSum = unweightedSum;
+            nestedList = nextLevel;
         }
 
         return weightedSum;
@@ -62,19 +63,20 @@ public static void main(String[] args) {
 
         assertEquals(0, nestedSum(Collections.singletonList(new NestedInteger().add(new NestedInteger()))));
 
+        // TODO: fix the test cases
+
+        // {2, {1,1}, {1,1}}
         NestedInteger ni = new NestedInteger(2);
         ni.add(new NestedInteger().add(new NestedInteger(1)).add(new NestedInteger(1)));
         ni.add(new NestedInteger().add(new NestedInteger(1)).add(new NestedInteger(1)));
 
-        assertEquals(10, nestedSum(Collections.singletonList(ni)));
+        assertEquals(6, nestedSum(Collections.singletonList(ni)));
 
+        // {1, {4, {6}}}
         ni = new NestedInteger(1);
         ni.add(new NestedInteger(4).add(new NestedInteger(6)));
 
-        assertEquals(27, nestedSum(Collections.singletonList(ni)));
-
-        /*assertEquals(10, nestedSum(new Object[]{new Object[]{1, 1}, 2, new Object[]{1, 1}}));
-        assertEquals(27, nestedSum(new Object[]{1, new Object[]{4, new Object[]{6}}}));*/
+        assertEquals(17, nestedSum(Collections.singletonList(ni)));
     }
 }
 

src/main/java/com/leetcode/arrays/ShortestWordDistance.java

@@ -26,7 +26,7 @@ public class ShortestWordDistance {
     /**
      * Time Complexity:
      * Space Complexity:
-     * TODO
+     * Runtime: <a href="https://leetcode.com/submissions/detail/248572791/">1 ms</a>.
      *
      * @param words
      * @param word1
@@ -41,8 +41,7 @@ public static int findShortestDistance(String[] words, String word1, String word
         for (int i = 0; i < words.length; i++) {
             if (words[i].equals(word1)) {
                 indexWord1 = i;
-            }
-            if (words[i].equals(word2)) {
+            } else if (words[i].equals(word2)) {
                 indexWord2 = i;
             }
             if (indexWord1 != -1 && indexWord2 != -1) {

src/main/java/com/leetcode/dynamicprogramming/PaintHouse.java

@@ -20,6 +20,8 @@
 public class PaintHouse {
 
     /**
+     * Runtime: <a href="https://leetcode.com/submissions/detail/248573066/">1 ms</a>.
+     *
      * @param costs of coloring the houses with red, blue, and green respectively. 1st row represents house 1, 2nd row
      *              house 2 and so on
      * @return the minimum cost to paint all houses such that no two adjacent houses are of same color

src/main/java/com/leetcode/maps/ShortestWordDistanceII.java

@@ -39,6 +39,13 @@ public class ShortestWordDistanceII {
         this.wordsToIndexesMap = getWordsToIndexesMap();
     }
 
+    /**
+     * Runtime: <a href="https://leetcode.com/submissions/detail/248572352/">65 ms</a>.
+     *
+     * @param word1
+     * @param word2
+     * @return
+     */
     public int findShortestDistance(String word1, String word2) {
         return findShortestDistance(wordsToIndexesMap.get(word1), wordsToIndexesMap.get(word2));
     }

src/main/java/com/leetcode/trees/ClosestBinarySearchTreeValueII.java

@@ -0,0 +1,76 @@
+package com.leetcode.trees;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Level: Hard
+ * Problem Link: https://leetcode.com/problems/closest-binary-search-tree-value-ii/ (premium)
+ * Problem Description:
+ *
+ *
+ * @author rampatra
+ * @since 2019-07-31
+ */
+public class ClosestBinarySearchTreeValueII {
+
+    /**
+     * @param node
+     * @param parentNode
+     * @param val
+     * @param diff
+     * @return
+     */
+    public static TreeNode findNodeWithClosestValue(TreeNode node, TreeNode parentNode, int val, int diff) {
+        return null;
+    }
+
+    public static void main(String[] args) {
+
+        /*
+            BST looks like:
+
+                    9
+                  /   \
+                 7     13
+                / \      \
+               5   8      20
+              / \
+             2   6
+         */
+        TreeNode root = new TreeNode(9);
+        root.left = new TreeNode(7);
+        root.right = new TreeNode(13);
+        root.left.left = new TreeNode(5);
+        root.left.right = new TreeNode(8);
+        root.left.left.left = new TreeNode(2);
+        root.left.left.right = new TreeNode(6);
+        root.right.right = new TreeNode(20);
+
+        assertEquals(13, findNodeWithClosestValue(root, root, 15, Integer.MAX_VALUE).val);
+        assertEquals(13, findNodeWithClosestValue(root, root, 13, Integer.MAX_VALUE).val);
+        assertEquals(9, findNodeWithClosestValue(root, root, 9, Integer.MAX_VALUE).val);
+        assertEquals(2, findNodeWithClosestValue(root, root, 2, Integer.MAX_VALUE).val);
+        assertEquals(2, findNodeWithClosestValue(root, root, 1, Integer.MAX_VALUE).val);
+        assertEquals(6, findNodeWithClosestValue(root, root, 6, Integer.MAX_VALUE).val);
+        assertEquals(13, findNodeWithClosestValue(root, root, 11, Integer.MAX_VALUE).val); // tie b/w 9 and 13
+
+        /*
+            BST looks like:
+
+                    9
+                  /   \
+                 7     13
+                / \   /  \
+               5   8 13  20
+         */
+        root = new TreeNode(9);
+        root.left = new TreeNode(7);
+        root.right = new TreeNode(13);
+        root.left.left = new TreeNode(5);
+        root.left.right = new TreeNode(8);
+        root.right.left = new TreeNode(13);
+        root.right.right = new TreeNode(20);
+
+        assertEquals(13, findNodeWithClosestValue(root, root, 15, Integer.MAX_VALUE).val);
+    }
+}

src/main/java/com/leetcode/trees/LeavesOfBinaryTree.java

@@ -45,18 +45,18 @@ public class LeavesOfBinaryTree {
      * the node into the list indexed by their heights.
      * Time Complexity:
      * Space Complexity:
-     * Runtime: <a href=""></a>.
+     * Runtime: <a href="https://leetcode.com/submissions/detail/248573435/">1 ms</a>.
      *
      * @param root
      * @return
      */
-    public static List<List<TreeNode>> findLeavesOfBinaryTree(TreeNode root) {
-        List<List<TreeNode>> levels = new ArrayList<>();
+    public static List<List<Integer>> findLeavesOfBinaryTree(TreeNode root) {
+        List<List<Integer>> levels = new ArrayList<>();
         findLeavesOfBinaryTree(root, levels);
         return levels;
     }
 
-    private static int findLeavesOfBinaryTree(TreeNode root, List<List<TreeNode>> levels) {
+    private static int findLeavesOfBinaryTree(TreeNode root, List<List<Integer>> levels) {
         if (root == null) return -1;
 
         int leftHeight = findLeavesOfBinaryTree(root.left, levels);
@@ -66,7 +66,7 @@ private static int findLeavesOfBinaryTree(TreeNode root, List<List<TreeNode>> le
         if (height >= levels.size()) {
             levels.add(height, new ArrayList<>());
         }
-        levels.get(height).add(root);
+        levels.get(height).add(root.val);
 
         return height;
     }

src/main/java/com/leetcode/trees/SecondMinNodeInBinaryTree.java

@@ -0,0 +1,108 @@
+package com.leetcode.trees;
+
+import java.util.Stack;
+
+/**
+ * Level: Easy
+ * Problem Link: https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/
+ * Problem Description:
+ * Given a non-empty special binary tree consisting of nodes with the non-negative value, where each node in this
+ * tree has exactly two or zero sub-node. If the node has two sub-nodes, then this node's value is the smaller value
+ * among its two sub-nodes. More formally, the property root.val = min(root.left.val, root.right.val) always holds.
+ *
+ * Given such a binary tree, you need to output the second minimum value in the set made of all the nodes' value in
+ * the whole tree.
+ *
+ * If no such second minimum value exists, output -1 instead.
+ *
+ * Example 1:
+ * Input:
+ *     2
+ *    / \
+ *   2   5
+ *      / \
+ *     5   7
+ *
+ * Output: 5
+ * Explanation: The smallest value is 2, the second smallest value is 5.
+ *
+ *
+ * Example 2:
+ * Input:
+ *     2
+ *    / \
+ *   2   2
+ *
+ * Output: -1
+ * Explanation: The smallest value is 2, but there isn't any second smallest value.
+ *
+ * @author rampatra
+ * @since 2019-08-03
+ */
+public class SecondMinNodeInBinaryTree {
+
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     * Runtime: <a href="https://leetcode.com/submissions/detail/248556303/">1 ms</a>.
+     * @param root
+     * @return
+     */
+    public static int findSecondMinimumValueIterative(TreeNode root) {
+        if (root == null || (root.left == null && root.right == null)) return -1;
+
+        int min = root.val;
+        long secondMin = Long.MAX_VALUE;
+
+        Stack<TreeNode> stack = new Stack<>();
+        stack.push(root);
+
+        while (!stack.empty()) {
+            TreeNode node = stack.pop();
+            if (node == null) continue;
+
+            if (node.val > min && node.val < secondMin) {
+                secondMin = node.val;
+            }
+            stack.push(node.left);
+            stack.push(node.right);
+        }
+
+        return secondMin == Long.MAX_VALUE ? -1 : (int) secondMin;
+    }
+
+
+    /**
+     * Time Complexity:
+     * Space Complexity:
+     * Runtime: <a href="https://leetcode.com/submissions/detail/248558543/">0 ms</a>.
+     *
+     * @param root
+     * @return
+     */
+    public static int findSecondMinimumValue(TreeNode root) {
+        // passing a long as secondMin because TreeNode can have Integer.MAX_VALUE as its value
+        long ans = findSecondMinimumValue(root, root.val, Long.MAX_VALUE);
+        return ans == Long.MAX_VALUE ? -1 : (int) ans;
+    }
+
+    private static long findSecondMinimumValue(TreeNode root, int min, long secondMin) {
+        if (root == null) return Long.MAX_VALUE;
+
+        if (root.val > min && root.val < secondMin) {
+            return root.val;
+        } else {
+            return Math.min(findSecondMinimumValue(root.left, min, secondMin),
+            findSecondMinimumValue(root.right, min, secondMin));
+        }
+    }
+
+    public static void main(String[] args) {
+        System.out.println((int) 2147483647L);
+        System.out.println(Integer.MAX_VALUE);
+        // TODO: A function called buildTree which would take an array like [1,1,3,1,1,3,4,3,1,1,1,3,8,4,8,3,3,1,6,2,1]
+        //  and return a Binary Tree
+        //assertEquals(2, findSecondMinimumValue(buildTree(new int[]{1,1,3,1,1,3,4,3,1,1,1,3,8,4,8,3,3,1,6,2,1})));
+        //assertEquals(2147483647, findSecondMinimumValue(buildTree(new int[]{2,2,2147483647})));
+    }
+}