add DesignHitCounter, MaxSumOfRectangleNoLargerThanK, PlusOneLinkedList, DesignPhoneDirectory

Author: FreeTymeKiyan

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

@@ -1,6 +1,8 @@
 package com.freetymekiyan.algorithms.level.easy;
 
 /**
+ * 371. Sum of Two Integers
+ * <p>
  * Calculate the sum of two integers a and b, but you are not allowed to use the operator + and -.
  * <p>
  * Example:
@@ -11,29 +13,29 @@
  */
 public class SumOfTwoIntegers {
 
-    /**
-     * For example, a = 0001, b = 0011.
-     * First, we can use "and"("&") operation between a and b to find a carry.
-     * carry = a & b, then carry = 0001
-     * Second, we can use "xor" ("^") operation between a and b to find the different bit, and assign it to a.
-     * Then, we shift carry one position left and assign it to b, b = 0010.
-     * Iterate until there is no carry (or b == 0)
-     */
-    public int getSum(int a, int b) {
-        if (b == 0) return a;
-
-        while (b != 0) {
-            int carry = a & b;
-            a = a ^ b;
-            b = carry << 1;
-        }
+  /**
+   * For example, a = 0001, b = 0011.
+   * First, we can use "and"("&") operation between a and b to find a carry.
+   * carry = a & b, then carry = 0001
+   * Second, we can use "xor" ("^") operation between a and b to find the different bit, and assign it to a.
+   * Then, we shift carry one position left and assign it to b, b = 0010.
+   * Iterate until there is no carry (or b == 0)
+   */
+  public int getSum(int a, int b) {
+    if (b == 0) return a;
 
-        return a;
+    while (b != 0) {
+      int carry = a & b;
+      a = a ^ b;
+      b = carry << 1;
     }
 
-    public int getSumRecursive(int a, int b) {
-        if (b == 0) return a;
-        return getSumRecursive(a ^ b, (a & b) << 1);
-    }
+    return a;
+  }
+
+  public int getSumRecursive(int a, int b) {
+    if (b == 0) return a;
+    return getSumRecursive(a ^ b, (a & b) << 1);
+  }
 
 }

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

@@ -0,0 +1,59 @@
+package com.freetymekiyan.algorithms.level.hard;
+
+import java.util.TreeSet;
+
+/**
+ * 363. Max Sum of Rectangle No Larger Than K
+ * <p>
+ * Given a non-empty 2D matrix matrix and an integer k, find the max sum of a rectangle in the matrix such that its sum
+ * is no larger than k.
+ * <p>
+ * Example:
+ * <p>
+ * Input: matrix = [[1,0,1],[0,-2,3]], k = 2
+ * Output: 2
+ * Explanation: Because the sum of rectangle [[0, 1], [-2, 3]] is 2,
+ * and 2 is the max number no larger than k (k = 2).
+ * Note:
+ * <p>
+ * The rectangle inside the matrix must have an area > 0.
+ * What if the number of rows is much larger than the number of columns?
+ * <p>
+ * Companies: Google, Facebook
+ * <p>
+ * Related Topics: Binary Search, Dynamic Programming, Queue
+ */
+public class MaxSumOfRectangleNoLargerThanK {
+
+  public int maxSumSubmatrix(int[][] matrix, int target) {
+    int row = matrix.length;
+    if (row == 0) return 0;
+    int col = matrix[0].length;
+    int m = Math.min(row, col);
+    int n = Math.max(row, col);
+    //indicating sum up in every row or every column
+    boolean colIsBig = col > row;
+    int res = Integer.MIN_VALUE;
+    for (int i = 0; i < m; i++) {
+      int[] array = new int[n];
+      // sum from row j to row i
+      for (int j = i; j >= 0; j--) {
+        int val = 0;
+        TreeSet<Integer> set = new TreeSet<Integer>();
+        set.add(0);
+        //traverse every column/row and sum up
+        for (int k = 0; k < n; k++) {
+          array[k] = array[k] + (colIsBig ? matrix[j][k] : matrix[k][j]);
+          val = val + array[k];
+          //use  TreeMap to binary search previous sum to get possible result
+          Integer subres = set.ceiling(val - target);
+          if (null != subres) {
+            res = Math.max(res, val - subres);
+          }
+          set.add(val);
+        }
+      }
+    }
+    return res;
+  }
+}

src/main/java/com/freetymekiyan/algorithms/level/medium/BombEnemy.java

@@ -23,57 +23,57 @@
  */
 public class BombEnemy {
 
-    private static final char WALL = 'W';
-    private static final char ENEMY = 'E';
-    private static final char EMPTY = '0';
+  private static final char WALL = 'W';
+  private static final char ENEMY = 'E';
+  private static final char EMPTY = '0';
 
-    /**
-     * DP.
-     * Avoid duplicate searching for number of enemies on the cell's left and top.
-     * Since they will be already traversed.
-     * So maintain an integer of number of enemy hits of current row, rowHits.
-     * Maintain an array of integers of numbers of enemy hits of each column, colHits of size grid[0].length.
-     * Recurrence Relation:
-     * rowHits = from this cell to the end of row or WALL. Re-calculate when j = 0 or left cell is a 'W'.
-     * colHits = from this cell to the bottom of column or WALL. Re-calculate when i = 0 or top cell is a 'W'.
-     * When the cell is 'E' (empty), we can place a bomb.
-     * Update the max with rowHits + colHits[j] if bigger.
-     */
-    public int maxKilledEnemies(char[][] grid) {
-        if (grid == null) {
-            return 0;
+  /**
+   * DP.
+   * Avoid duplicate searching for number of enemies on the cell's left and top.
+   * Since they will be already traversed.
+   * So maintain an integer of number of enemy hits of current row, rowHits.
+   * Maintain an array of integers of numbers of enemy hits of each column, colHits of size grid[0].length.
+   * Recurrence Relation:
+   * rowHits = from this cell to the end of row or WALL. Re-calculate when j = 0 or left cell is a 'W'.
+   * colHits = from this cell to the bottom of column or WALL. Re-calculate when i = 0 or top cell is a 'W'.
+   * When the cell is 'E' (empty), we can place a bomb.
+   * Update the max with rowHits + colHits[j] if bigger.
+   */
+  public int maxKilledEnemies(char[][] grid) {
+    if (grid == null) {
+      return 0;
+    }
+    int m = grid.length;
+    int n = m == 0 ? 0 : grid[0].length;
+    int maxEnemies = 0;
+    int rowHits = 0;
+    int[] colHits = new int[n];
+    for (int i = 0; i < m; i++) {
+      for (int j = 0; j < n; j++) {
+        if (grid[i][j] == WALL) { // Note that WALL can be skipped.
+          continue;
+        }
+        if (j == 0 || grid[i][j - 1] == WALL) {
+          rowHits = 0;
+          for (int k = j; k < n && grid[i][k] != WALL; k++) {
+            if (grid[i][k] == ENEMY) {
+              rowHits++;
+            }
+          }
         }
-        int m = grid.length;
-        int n = m == 0 ? 0 : grid[0].length;
-        int maxEnemies = 0;
-        int rowHits = 0;
-        int[] colHits = new int[n];
-        for (int i = 0; i < m; i++) {
-            for (int j = 0; j < n; j++) {
-                if (grid[i][j] == WALL) { // Note that WALL can be skipped.
-                    continue;
-                }
-                if (j == 0 || grid[i][j - 1] == WALL) {
-                    rowHits = 0;
-                    for (int k = j; k < n && grid[i][k] != WALL; k++) {
-                        if (grid[i][k] == ENEMY) {
-                            rowHits++;
-                        }
-                    }
-                }
-                if (i == 0 || grid[i - 1][j] == WALL) {
-                    colHits[j] = 0;
-                    for (int k = i; k < m && grid[k][j] != WALL; k++) {
-                        if (grid[k][j] == ENEMY) {
-                            colHits[j]++;
-                        }
-                    }
-                }
-                if (grid[i][j] == EMPTY) { // Only update when the cell is empty.
-                    maxEnemies = Integer.max(rowHits + colHits[j], maxEnemies);
-                }
+        if (i == 0 || grid[i - 1][j] == WALL) {
+          colHits[j] = 0;
+          for (int k = i; k < m && grid[k][j] != WALL; k++) {
+            if (grid[k][j] == ENEMY) {
+              colHits[j]++;
             }
+          }
+        }
+        if (grid[i][j] == EMPTY) { // Only update when the cell is empty.
+          maxEnemies = Integer.max(rowHits + colHits[j], maxEnemies);
         }
-        return maxEnemies;
+      }
     }
+    return maxEnemies;
+  }
 }

src/main/java/com/freetymekiyan/algorithms/level/medium/CombinationSum4.java

@@ -40,50 +40,50 @@
  */
 public class CombinationSum4 {
 
-    /**
-     * DP, Bottom-up. O(n^2) Time, O(n) Space.
-     * State: S[i] means the # of combinations that can reach sum i.
-     * Recurrent relation:
-     * S[i] = sum(S[i - nums[j]]), where 0 <= j < nums.length, and target >= nums[j].
-     * Base case:
-     * S[0] = 1. Think about [1], 1, where S[1] = S[1 - 1] = S[0] = 1.
-     */
-    public int combinationSum4(int[] nums, int target) {
-        int[] comb = new int[target + 1];
-        comb[0] = 1;
-        for (int i = 1; i < comb.length; i++) {
-            for (int j = 0; j < nums.length; j++) {
-                if (i - nums[j] >= 0) { // Array's not sorted. Need to check each number.
-                    comb[i] += comb[i - nums[j]];
-                }
-            }
+  /**
+   * DP, Bottom-up. O(n^2) Time, O(n) Space.
+   * State: S[i] means the # of combinations that can reach sum i.
+   * Recurrent relation:
+   * S[i] = sum(S[i - nums[j]]), where 0 <= j < nums.length, and target >= nums[j].
+   * Base case:
+   * S[0] = 1. Think about [1], 1, where S[1] = S[1 - 1] = S[0] = 1.
+   */
+  public int combinationSum4(int[] nums, int target) {
+    int[] comb = new int[target + 1];
+    comb[0] = 1;
+    for (int i = 1; i < comb.length; i++) {
+      for (int j = 0; j < nums.length; j++) {
+        if (i - nums[j] >= 0) { // Array's not sorted. Need to check each number.
+          comb[i] += comb[i - nums[j]];
         }
-        return comb[target];
+      }
     }
+    return comb[target];
+  }
 
-    /**
-     * DP, Top-down, Memoization.
-     */
-    public int combinationSum4TopDown(int[] nums, int target) {
-        int[] dp = new int[target + 1];
-        Arrays.fill(dp, -1);
-        return helper(nums, target, dp);
-    }
+  /**
+   * DP, Top-down, Memoization.
+   */
+  public int combinationSum4TopDown(int[] nums, int target) {
+    int[] dp = new int[target + 1];
+    Arrays.fill(dp, -1);
+    return helper(nums, target, dp);
+  }
 
-    private int helper(int[] nums, int target, int[] dp) {
-        if (target == 0) {
-            return 1;
-        }
-        if (dp[target] != -1) {
-            return dp[target];
-        }
-        int res = 0;
-        for (int i = 0; i < nums.length; i++) {
-            if (target >= nums[i]) {
-                res += helper(nums, target - nums[i], dp);
-            }
-        }
-        dp[target] = res;
-        return res;
+  private int helper(int[] nums, int target, int[] dp) {
+    if (target == 0) {
+      return 1;
+    }
+    if (dp[target] != -1) {
+      return dp[target];
+    }
+    int res = 0;
+    for (int i = 0; i < nums.length; i++) {
+      if (target >= nums[i]) {
+        res += helper(nums, target - nums[i], dp);
+      }
     }
+    dp[target] = res;
+    return res;
+  }
 }