[N-0] add 727

Author: fishercoder1534

README.md

@@ -22,6 +22,7 @@ Your ideas/fixes/algorithms are more than welcome!
 
 |  #  |      Title     |   Solutions   | Time          | Space         | Difficulty  | Tag          | Notes
 |-----|----------------|---------------|---------------|---------------|-------------|--------------|-----
+|727|[Minimum Window Subsequence](https://leetcode.com/problems/minimum-window-subsequence/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_727.java) | O(m*n) | O(m*n) | Hard | DP
 |725|[Split Linked List in Parts](https://leetcode.com/problems/split-linked-list-in-parts/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_725.java) | O(n+k) | O(k) | Medium | LinkedList
 |724|[Find Pivot Index](https://leetcode.com/problems/find-pivot-index/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_724.java) | O(n) | O(1) | Easy | Array
 |723|[Candy Crush](https://leetcode.com/problems/candy-crush/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_723.java) | O((r*c)^2) | O((r*c)) | Medium | Array, Two Pointers

src/main/java/com/fishercoder/solutions/_727.java

@@ -0,0 +1,82 @@
+package com.fishercoder.solutions;
+
+import java.util.Arrays;
+
+/**
+ * 727. Minimum Window Subsequence
+ *
+ * Given strings S and T, find the minimum (contiguous) substring W of S, so that T is a subsequence of W.
+ * If there is no such window in S that covers all characters in T,
+ * return the empty string "". If there are multiple such minimum-length windows, return the one with the left-most starting index.
+
+ Example 1:
+ Input:
+ S = "abcdebdde", T = "bde"
+ Output: "bcde"
+
+ Explanation:
+ "bcde" is the answer because it occurs before "bdde" which has the same length.
+ "deb" is not a smaller window because the elements of T in the window must occur in order.
+
+ Note:
+ All the strings in the input will only contain lowercase letters.
+ The length of S will be in the range [1, 20000].
+ The length of T will be in the range [1, 100].
+ */
+public class _727 {
+    public static class Solution1 {
+        /**
+         * This naive brute force results in TLE.
+         */
+        public String minWindow(String S, String T) {
+            String result = S;
+            for (int i = 0; i < S.length(); i++) {
+                for (int j = i + T.length(); j <= S.length(); j++) {
+                    String sub = S.substring(i, j);
+                    if (sub.length() < result.length() && isSubsequence(T, sub)) {
+                        result = sub;
+                    }
+                }
+            }
+            return result.equals(S) ? "" : result;
+        }
+
+        private boolean isSubsequence(String T, String sub) {
+            int i = 0;
+            for (int j = 0; i < T.length() && j < sub.length(); j++) {
+                if (T.charAt(i) == sub.charAt(j)) {
+                    i++;
+                }
+            }
+            return i == T.length();
+        }
+    }
+
+    public static class Solution2 {
+        /**credit: https://github.com/lydxlx1/LeetCode/blob/master/src/_727.java*/
+        public String minWindow(String S, String T) {
+            int[][] dp = new int[S.length() + 1][T.length() + 1];
+            int INFINITY = 1 << 29;
+            Arrays.fill(dp[0], INFINITY);
+            dp[0][0] = 0;
+            for (int i = 1; i <= S.length(); i++) {
+                for (int j = 1; j <= T.length(); j++) {
+                    dp[i][j] = dp[i - 1][j] + 1;
+                    if (S.charAt(i - 1) == T.charAt(j - 1)) {
+                        dp[i][j] = dp[i - 1][j - 1] + 1;
+                    }
+                }
+            }
+            int ans = INFINITY;
+            int tail = -1;
+            for (int i = 1; i <= S.length(); i++) {
+                if (dp[i][T.length()] < ans) {
+                    ans = dp[i][T.length()];
+                    tail = i;
+                }
+            }
+            return ans == INFINITY ? "" : S.substring(tail - ans, tail);
+        }
+
+    }
+}

src/test/java/com/fishercoder/_727Test.java

@@ -0,0 +1,37 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._727;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _727Test {
+    private static _727.Solution1 solution1;
+    private static _727.Solution2 solution2;
+    private static String S;
+    private static String T;
+
+    @Before
+    public void setup() {
+        solution1 = new _727.Solution1();
+        solution2 = new _727.Solution2();
+    }
+
+    @Test
+    public void test1() {
+        S = "abcdebdde";
+        T = "bde";
+        assertEquals("bcde", solution1.minWindow(S, T));
+        assertEquals("bcde", solution2.minWindow(S, T));
+    }
+
+    @Test
+    public void test2() {
+        String S = "jmeqksfrsdcmsiwvaovztaqenprpvnbstl";
+        String T = "l";
+        assertEquals("l", solution1.minWindow(S, T));
+        assertEquals("l", solution2.minWindow(S, T));
+    }
+
+}