update solutions

Author: FreeTymeKiyan

src/main/java/com/freetymekiyan/algorithms/level/easy/ExcelSheetColNum.java

@@ -0,0 +1,40 @@
+package com.freetymekiyan.algorithms.level.easy;
+
+/**
+ * Related to question Excel Sheet Column Title
+ * <p>
+ * Given a column title as appear in an Excel sheet, return its corresponding
+ * column number.
+ * <p>
+ * For example:
+ * <p>
+ * A -> 1
+ * B -> 2
+ * C -> 3
+ * ...
+ * Z -> 26
+ * AA -> 27
+ * AB -> 28
+ * <p>
+ * Tags: Math
+ */
+class ExcelSheetColNumber {
+
+  public static void main(String[] args) {
+    System.out.println(titleToNumber("AAA"));
+  }
+
+  /**
+   * Go through the title
+   * Map A ~ Z to 1 ~ 26
+   * next result = current res * 26 + number of current letter
+   */
+  public static int titleToNumber(String s) {
+    if (s == null || s.length() == 0) return 0;
+    int res = 0;
+    for (int i = 0; i < s.length(); i++) {
+      res = res * 26 + (s.charAt(i) - '@');
+    }
+    return res;
+  }
+}

src/main/java/com/freetymekiyan/algorithms/level/easy/ExcelSheetColNumber.java

@@ -2,32 +2,33 @@
 
 /**
  * Given an integer n, return the number of trailing zeroes in n!.
- * 
+ * <p>
  * Note: Your solution should be in logarithmic time complexity.
- * 
+ * <p>
  * Tag: Math
  */
 class FactorialTrailingZeroes {
-    public static void main(String[] args) {
-        System.out.println(trailingZeroes(20));
-    }
-    
-    /**
-     * O(log5-n)
-     */
-    public static int trailingZeroes(int n) {
-        int r = 0;
-        while (n > 0) {
-            n /= 5;
-            r += n; // add # of 5 in n
-        }
-        return r;
-    }
-    
-    /**
-     * Recursive
-     */
-    public static int trailingZeroesB(int n) {
-        return n <= 0 ? 0 : n / 5 + trailingZeroes(n / 5);
+
+  public static void main(String[] args) {
+    System.out.println(trailingZeroes(20));
+  }
+
+  /**
+   * O(log5-n)
+   */
+  public static int trailingZeroes(int n) {
+    int r = 0;
+    while (n > 0) {
+      n /= 5;
+      r += n; // add # of 5 in n
     }
+    return r;
+  }
+
+  /**
+   * Recursive
+   */
+  public static int trailingZeroesB(int n) {
+    return n <= 0 ? 0 : n / 5 + trailingZeroes(n / 5);
+  }
 }

src/main/java/com/freetymekiyan/algorithms/level/easy/FactorialTrailingZeroes.java

@@ -6,73 +6,69 @@
  * out in a 2D grid. Our valiant knight (K) was initially positioned in the
  * top-left room and must fight his way through the dungeon to rescue the
  * princess.
- * 
+ * <p>
  * The knight has an initial health point represented by a positive integer. If
  * at any point his health point drops to 0 or below, he dies immediately.
- * 
+ * <p>
  * Some of the rooms are guarded by demons, so the knight loses health
  * (negative integers) upon entering these rooms; other rooms are either empty
  * (0's) or contain magic orbs that increase the knight's health (positive
  * integers).
- * 
+ * <p>
  * In order to reach the princess as quickly as possible, the knight decides to
  * move only rightward or downward in each step.
- * 
+ * <p>
  * Write a function to determine the knight's minimum initial health so that he
  * is able to rescue the princess.
- * 
+ * <p>
  * For example, given the dungeon below, the initial health of the knight must
  * be at least 7 if he follows the optimal path RIGHT-> RIGHT -> DOWN -> DOWN.
- * 
+ * <p>
  * -2(K)    -3      3
  * -5       -10     1
  * 10       30      -5(P)
- * 
+ * <p>
  * Notes:
  * The knight's health has no upper bound.
  * Any room can contain threats or power-ups, even the first room the knight
  * enters and the bottom-right room where the princess is imprisoned.
- * 
+ * <p>
  * Tags:DP, Binary Search
  */
 class DungeonGame {
-    
-    public static void main(String[] args) {
-        
-    }
-    
-    /**
-     * Build a table for the minimum hp needed to get to the bottom right
-     * Build from bottom right to get minimum from i, j to the end
-     * Instead of build from to-left, because it's hard to get correct relation
-     */
-    public int calculateMinimumHP(int[][] dungeon) {
-        if (dungeon == null || dungeon.length == 0 || dungeon[0].length == 0) return 0;
-        int m = dungeon.length - 1;
-        int n = dungeon[0].length - 1;
-        dungeon[m][n] = Math.max(1 - dungeon[m][n], 1);
-        for (int i = m - 1; i >= 0; i--) dungeon[i][n] = Math.max(dungeon[i + 1][n] - dungeon[i][n], 1);
-        for (int j = n - 1; j >= 0; j--) dungeon[m][j] = Math.max(dungeon[m][j + 1] - dungeon[m][j], 1);
-        for (int i = m - 1; i >= 0; i--) {
-            for (int j = n - 1; j >= 0; j--) {
-                dungeon[i][j] = Math.max(Math.min(dungeon[i + 1][j], dungeon[i][j + 1]) - dungeon[i][j], 1);
-            }
-        }
-        return dungeon[0][0];
+
+  /**
+   * Build a table for the minimum hp needed to get to the bottom right
+   * Build from bottom right to get minimum from i, j to the end
+   * Instead of build from to-left, because it's hard to get correct relation
+   */
+  public int calculateMinimumHP(int[][] dungeon) {
+    if (dungeon == null || dungeon.length == 0 || dungeon[0].length == 0) return 0;
+    int m = dungeon.length - 1;
+    int n = dungeon[0].length - 1;
+    dungeon[m][n] = Math.max(1 - dungeon[m][n], 1);
+    for (int i = m - 1; i >= 0; i--) dungeon[i][n] = Math.max(dungeon[i + 1][n] - dungeon[i][n], 1);
+    for (int j = n - 1; j >= 0; j--) dungeon[m][j] = Math.max(dungeon[m][j + 1] - dungeon[m][j], 1);
+    for (int i = m - 1; i >= 0; i--) {
+      for (int j = n - 1; j >= 0; j--) {
+        dungeon[i][j] = Math.max(Math.min(dungeon[i + 1][j], dungeon[i][j + 1]) - dungeon[i][j], 1);
+      }
     }
-    /**
-     * Why “from the bottom right corner to left top”?
-     * It depends on the way you formulate the problem. If you define a value
-     * in DP table d[i][j] as 'the minimum hp required to REACH (i, j) from (0,
-     * 0)", then the final answer should be d[nrows-1][ncols-1], and you need
-     * to start filling from the top left; 
-     * However, in the reference answer provided with the question, dp[i][j] is 
-     * defined as 'the minimum hp required to REACH (nrows-1, ncols-1) from (i,
-     * j)'. Here dp[0][0] is the final answer so we must fill from (nrows-1, 
-     * ncols-1). For many other problems such as 'Minimum Path Sum', both 
-     * formulation would work. 
-     * However, in this problem, the former formulation will lead us to 
-     * trouble, because it is very hard, if not impossible, to get d[i][j] 
-     * based on d[i-1][j] and d[i][j-1].
-     */
+    return dungeon[0][0];
+  }
+  /**
+   * Why “from the bottom right corner to left top”?
+   * It depends on the way you formulate the problem. If you define a value
+   * in DP table d[i][j] as 'the minimum hp required to REACH (i, j) from (0,
+   * 0)", then the final answer should be d[nrows-1][ncols-1], and you need
+   * to start filling from the top left;
+   * However, in the reference answer provided with the question, dp[i][j] is
+   * defined as 'the minimum hp required to REACH (nrows-1, ncols-1) from (i,
+   * j)'. Here dp[0][0] is the final answer so we must fill from (nrows-1,
+   * ncols-1). For many other problems such as 'Minimum Path Sum', both
+   * formulation would work.
+   * However, in this problem, the former formulation will lead us to
+   * trouble, because it is very hard, if not impossible, to get d[i][j]
+   * based on d[i-1][j] and d[i][j-1].
+   */
 }

src/main/java/com/freetymekiyan/algorithms/level/hard/DungeonGame.java

@@ -22,40 +22,40 @@
  */
 public class BinarySearchTreeIterator {
 
-    Deque<TreeNode> stack;
-
-    /**
-     * Simulate in-order traversal.
-     * Push all left children into a Stack to get prepared.
-     */
-    public BinarySearchTreeIterator(TreeNode root) {
-        stack = new ArrayDeque<>();
-        pushAllLeft(root);
-    }
-
-    /**
-     * If the stack is empty, there is no more node left.
-     */
-    public boolean hasNext() {
-        return !stack.isEmpty();
-    }
-
-    /**
-     * Imagine all left subtree of a node is popped out.
-     * The next will be itself.
-     * And then the next will be its right subtree.
-     * The right subtree repeats the pattern of pushing all left children into a stack.
-     */
-    public int next() {
-        TreeNode n = stack.pop();
-        pushAllLeft(n.right); // Left subtree and root is done. Repeat on right subtree.
-        return n.val;
-    }
-
-    private void pushAllLeft(TreeNode root) {
-        while (root != null) {
-            stack.push(root);
-            root = root.left;
-        }
+  Deque<TreeNode> stack;
+
+  /**
+   * Simulate in-order traversal.
+   * Push all left children into a Stack to get prepared.
+   */
+  public BinarySearchTreeIterator(TreeNode root) {
+    stack = new ArrayDeque<>();
+    pushAllLeft(root);
+  }
+
+  /**
+   * If the stack is empty, there is no more node left.
+   */
+  public boolean hasNext() {
+    return !stack.isEmpty();
+  }
+
+  /**
+   * Imagine all left subtree of a node is popped out.
+   * The next will be itself.
+   * And then the next will be its right subtree.
+   * The right subtree repeats the pattern of pushing all left children into a stack.
+   */
+  public int next() {
+    TreeNode n = stack.pop();
+    pushAllLeft(n.right); // Left subtree and root is done. Repeat on right subtree.
+    return n.val;
+  }
+
+  private void pushAllLeft(TreeNode root) {
+    while (root != null) {
+      stack.push(root);
+      root = root.left;
     }
+  }
 }