update solutions

Author: FreeTymeKiyan

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

@@ -15,25 +15,25 @@
  */
 public class MergeSortedArray {
 
-    /**
-     * Array. Two Pointers.
-     * One pointer i at the end of nums1. Another pointer j at the end of nums2.
-     * Compare their values and put the larger one at the end of nums1.
-     * The index is m + n - 1.
-     * If m - 1 == 0, nums1 is fully merged, merge the rest of nums2.
-     */
-    public void merge(int[] nums1, int m, int[] nums2, int n) {
-        for (int i = m - 1, j = n - 1, k = m + n - 1; k >= 0 && j >= 0; k--) {
-            nums1[k] = (i < 0 || nums1[i] < nums2[j]) ? nums2[j--] : nums1[i--];
-        }
+  /**
+   * Array. Two Pointers.
+   * One pointer i at the end of nums1. Another pointer j at the end of nums2.
+   * Compare their values and put the larger one at the end of nums1.
+   * The index is m + n - 1.
+   * If m - 1 == 0, nums1 is fully merged, merge the rest of nums2.
+   */
+  public void merge(int[] nums1, int m, int[] nums2, int n) {
+    for (int i = m - 1, j = n - 1, k = m + n - 1; k >= 0 && j >= 0; k--) {
+      nums1[k] = (i < 0 || nums1[i] < nums2[j]) ? nums2[j--] : nums1[i--];
     }
+  }
 
-    /**
-     * Instead of 3 indices, use m-1 for nums1, n-1 for nums2.
-     */
-    public void merge2(int[] nums1, int m, int[] nums2, int n) {
-        for (int i = m + n - 1; i >= 0 && n - 1 >= 0; i--) {
-            nums1[i] = (m - 1 < 0 || nums1[m - 1] < nums2[n - 1]) ? nums2[n-- - 1] : nums1[m-- - 1];
-        }
+  /**
+   * Instead of 3 indices, use m-1 for nums1, n-1 for nums2.
+   */
+  public void merge2(int[] nums1, int m, int[] nums2, int n) {
+    for (int i = m + n - 1; i >= 0 && n - 1 >= 0; i--) {
+      nums1[i] = (m - 1 < 0 || nums1[m - 1] < nums2[n - 1]) ? nums2[n-- - 1] : nums1[m-- - 1];
     }
+  }
 }

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

@@ -0,0 +1,75 @@
+package com.freetymekiyan.algorithms.level.hard;
+
+/**
+ * Given two words word1 and word2, find the minimum number of steps required
+ * to convert word1 to word2. (each operation is counted as 1 step.)
+ * <p>
+ * You have the following 3 operations permitted on a word:
+ * <p>
+ * a) Insert a character
+ * b) Delete a character
+ * c) Replace a character
+ * <p>
+ * Tags: DP, String
+ */
+class EditDistance {
+
+  /**
+   * DP, O(nm) Time, O(nm) Space
+   * Searching for a path (sequence of edits) from the start string to the
+   * final string
+   * For two strings, X of length n, Y of length m
+   * Define D(i,j): the edit distance between X[1..i] and Y[1..j]
+   * The edit distance between X and Y is thus D(n,m)
+   * <p>
+   * Initialization: D(i,0) = i, D(0,j) = j
+   * 1. D(i, j) = min(D(i - 1, j) + 1, D(i, j - 1) + 1, D(i - 1, j - 1) + 0
+   * or 1), 0 is X(i) = Y(j), 1 if X(i) != Y(j)
+   * D(N, M) is distance
+   * <p>
+   * Note that f[i][j] only depends on f[i-1][j-1], f[i-1][j] and f[i][j-1],
+   * therefore we can reduce the space to O(n) by using only the (i-1)th
+   * array and previous updated element(f[i][j-1]).
+   */
+  public static int minDistance(String word1, String word2) {
+    if (word1.equals(word2)) return 0;
+    int m = word1.length();
+    int n = word2.length();
+    int[][] d = new int[m + 1][n + 1];
+    d[0][0] = 0;
+    for (int i = 1; i < m + 1; i++) d[i][0] = i;
+    for (int j = 1; j < n + 1; j++) d[0][j] = j;
+
+    for (int i = 1; i < m + 1; i++) {
+      for (int j = 1; j < n + 1; j++) {
+        d[i][j] = Math.min(Math.min(d[i][j - 1] + 1, d[i - 1][j] + 1), word1.charAt(i - 1) == word2.charAt(j - 1) ? d[i - 1][j - 1] : d[i - 1][j - 1] + 1);
+      }
+    }
+
+    return d[m][n];
+  }
+
+  /**
+   * Optimal DP. Reduce table to a row.
+   */
+  public static int minDistanceOptimal(String word1, String word2) {
+    if (word1.equals(word2)) return 0;
+    int m = word1.length();
+    int n = word2.length();
+    int[] d = new int[n + 1];
+    d[0] = 0;
+    for (int j = 1; j < n + 1; j++) d[j] = j;
+
+    for (int i = 1; i < m + 1; i++) {
+      int prev = d[0];
+      d[0] += 1;
+      for (int j = 1; j < n + 1; j++) {
+        int temp = d[j];
+        d[j] = Math.min(Math.min(d[j - 1] + 1, d[j] + 1), word1.charAt(i - 1) == word2.charAt(j - 1) ? prev : prev + 1);
+        prev = temp;
+      }
+    }
+
+    return d[n];
+  }
+}

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

@@ -21,84 +21,84 @@
  */
 public class MaximalRectangle {
 
-    /**
-     * DP.
-     * Three matrices: left, right, and height.
-     * Height is number of continuous 1's that end at j.
-     * Left is the left boundary of this height. The actual value is an index.
-     * Right is the right boundary of this right. The actual value is index + 1.
-     * The rectangle area of this height at row i and column j is: [right(i,j) - left(i,j)] * height(i,j).
-     * <p>
-     * Recurrence relations:
-     * left(i,j) = max(left(i-1,j), leftBound)
-     * leftBound is the leftmost 1 of this height at current row.
-     * All left boundaries are initialized as 0, which is the leftmost possible.
-     * <p>
-     * right(i,j) = min(right(i-1,j), rightBound)
-     * rightBound is the rightmost 1 of this height at current row + 1.
-     * All right boundaries are initialized as n, which is the rightmost possible.
-     * <p>
-     * height(i,j) = height(i-1,j) + 1, if matrix[i][j]=='1'.
-     * height(i,j) = 0, if matrix[i][j]=='0'.
-     * <p>
-     * Implementation:
-     * Initialize left array and height as all zeroes, right array as the column length.
-     * For each row in the matrix, update height, left, right arrays.
-     * Then compute the area and record the maximum.
-     * Stop when all grids are done.
-     * https://discuss.leetcode.com/topic/6650/share-my-dp-solution
-     * <p>
-     * Note that the rectangle area we get is not the maximum at each grid, rather, it's the area of the rectangle of
-     * the maximum possible height.
-     * Why does that covers the maximum rectangle?
-     * Because:
-     * If the max rectangle has only 1 column, the bottom grid will have the max area.
-     * If the max rectangle has > 1 columns, the bottom row will have the max area.
-     */
-    public int maximalRectangle(char[][] matrix) {
-        int m = matrix.length;
-        int n = matrix[0].length;
-        int[] left = new int[n];
-        int[] right = new int[n];
-        int[] height = new int[n];
-//        Arrays.fill(left, 0);
-        Arrays.fill(right, n);
-//        Arrays.fill(height, 0);
-        int max = 0;
-        for (int i = 0; i < m; i++) {
-            // Compute height (can do this from either side).
-            for (int j = 0; j < n; j++) {
-                if (matrix[i][j] == '1') {
-                    height[j]++;
-                } else {
-                    height[j] = 0;
-                }
-            }
-            // Compute left boundaries (must from left to right).
-            int leftBound = 0; // Index of leftmost 1 of current row.
-            for (int j = 0; j < n; j++) {
-                if (matrix[i][j] == '1') {
-                    left[j] = Math.max(left[j], leftBound);
-                } else {
-                    left[j] = 0;
-                    leftBound = j + 1;
-                }
-            }
-            // Compute right boundaries (must from right to left).
-            int rightBound = n; // Index + 1 of rightmost 1 of current row.
-            for (int j = n - 1; j >= 0; j--) {
-                if (matrix[i][j] == '1') {
-                    right[j] = Math.min(right[j], rightBound);
-                } else {
-                    right[j] = n; // Like reset. Make sure right[j] >= curRight.
-                    rightBound = j;
-                }
-            }
-            // Compute the area of rectangle (can do this from either side).
-            for (int j = 0; j < n; j++) {
-                max = Math.max(max, (right[j] - left[j]) * height[j]);
-            }
+  /**
+   * DP.
+   * Three matrices: left, right, and height.
+   * Height is number of continuous 1's that end at j.
+   * Left is the left boundary of this height. The actual value is an index.
+   * Right is the right boundary of this right. The actual value is index + 1.
+   * The rectangle area of this height at row i and column j is: [right(i,j) - left(i,j)] * height(i,j).
+   * <p>
+   * Recurrence relations:
+   * left(i,j) = max(left(i-1,j), leftBound)
+   * leftBound is the leftmost 1 of this height at current row.
+   * All left boundaries are initialized as 0, which is the leftmost possible.
+   * <p>
+   * right(i,j) = min(right(i-1,j), rightBound)
+   * rightBound is the rightmost 1 of this height at current row + 1.
+   * All right boundaries are initialized as n, which is the rightmost possible.
+   * <p>
+   * height(i,j) = height(i-1,j) + 1, if matrix[i][j]=='1'.
+   * height(i,j) = 0, if matrix[i][j]=='0'.
+   * <p>
+   * Implementation:
+   * Initialize left array and height as all zeroes, right array as the column length.
+   * For each row in the matrix, update height, left, right arrays.
+   * Then compute the area and record the maximum.
+   * Stop when all grids are done.
+   * https://discuss.leetcode.com/topic/6650/share-my-dp-solution
+   * <p>
+   * Note that the rectangle area we get is not the maximum at each grid, rather, it's the area of the rectangle of
+   * the maximum possible height.
+   * Why does that covers the maximum rectangle?
+   * Because:
+   * If the max rectangle has only 1 column, the bottom grid will have the max area.
+   * If the max rectangle has > 1 columns, the bottom row will have the max area.
+   */
+  public int maximalRectangle(char[][] matrix) {
+    int m = matrix.length;
+    int n = matrix[0].length;
+    int[] left = new int[n];
+    int[] right = new int[n];
+    int[] height = new int[n];
+    // Arrays.fill(left, 0);
+    Arrays.fill(right, n);
+    // Arrays.fill(height, 0);
+    int max = 0;
+    for (int i = 0; i < m; i++) {
+      // Compute height (can do this from either side).
+      for (int j = 0; j < n; j++) {
+        if (matrix[i][j] == '1') {
+          height[j]++;
+        } else {
+          height[j] = 0;
         }
-        return max;
+      }
+      // Compute left boundaries (must from left to right).
+      int leftBound = 0; // Index of leftmost 1 of current row.
+      for (int j = 0; j < n; j++) {
+        if (matrix[i][j] == '1') {
+          left[j] = Math.max(left[j], leftBound);
+        } else {
+          left[j] = 0;
+          leftBound = j + 1;
+        }
+      }
+      // Compute right boundaries (must from right to left).
+      int rightBound = n; // Index + 1 of rightmost 1 of current row.
+      for (int j = n - 1; j >= 0; j--) {
+        if (matrix[i][j] == '1') {
+          right[j] = Math.min(right[j], rightBound);
+        } else {
+          right[j] = n; // Like reset. Make sure right[j] >= curRight.
+          rightBound = j;
+        }
+      }
+      // Compute the area of rectangle (can do this from either side).
+      for (int j = 0; j < n; j++) {
+        max = Math.max(max, (right[j] - left[j]) * height[j]);
+      }
     }
+    return max;
+  }
 }