Merge branch 'master' of ssh://111.230.181.241:1111/ikachan/leetcode-go

hard/30.substring-with-concatenation-of-all-words.java

@@ -1,5 +1,59 @@
+import java.util.*;
+
 class Solution {
+    class Frequency {
+        int val;
+
+        Frequency(int val) {
+            this.val = val;
+        }
+    }
+
     public List<Integer> findSubstring(String s, String[] words) {
-        int m, n;
+        List<Integer> res = new ArrayList<>();
+        int l, m, n;
+        if ((l = s.length()) == 0 || (m = words.length) == 0 || (n = words[0].length()) == 0)
+            return res; // String is empty or word list is empty or each word is empty
+        HashMap<String, Frequency> map = new HashMap<>();
+        for (String word : words) {
+            Frequency freq = map.get(word);
+            if (freq == null) map.put(word, new Frequency(1));
+            else freq.val++;
+        } // Count the frequency of each word in the word list
+        for (int i = 0; i < n; i++) { // Shift one character a time
+            HashMap<String, Frequency> window = new HashMap<>();
+            int begin = i, count = 0; // Begin of window, count of words in the window
+            for (int j = i; j < l - n + 1; j += n) {
+                String word = s.substring(j, j + n);
+                Frequency target = map.get(word);
+                if (target == null) { // Not in the word list, clear window & reset begin
+                    window.clear();
+                    begin = j + n;
+                    count = 0;
+                    continue;
+                }
+                Frequency occur = window.get(word); // Move right
+                if (occur == null) {
+                    occur = new Frequency(1);
+                    window.put(word, occur);
+                } else {
+                    occur.val++;
+                }
+                if (occur.val <= target.val) count++;
+                while (target.val < occur.val) { // Move left
+                    String remove = s.substring(begin, begin + n);
+                    begin += n;
+                    if (remove.equals(word)) {
+                        occur.val--;
+                    } else {
+                        Frequency freq = window.get(remove);
+                        freq.val--;
+                        count--;
+                    }
+                }
+                if (count == m) res.add(begin);
+            }
+        }
+        return res;
     }
 }

hard/32.longest-valid-parentheses.java

@@ -0,0 +1,5 @@
+class Solution {
+    public int longestValidParentheses(String s) {
+        
+    }
+}

hard/639.decode-ways-ii.go

@@ -2,9 +2,6 @@ const MOD int = 1000000007
 
 func numDecodings(s string) int {
 	n := len(s)
-	if n == 0 {
-		return 1
-	}
 	dp := make([]int, n+1)
 	dp[0] = 1
 	switch s[0] {

hard/639.decode-ways-ii.java

@@ -0,0 +1,35 @@
+class Solution {
+    private final int MOD = 1000000007;
+
+    public int numDecodings(String s) {
+        char[] chs = s.toCharArray(); // '*' means 1~9
+        if (chs[0] == '0') return 0;
+        int[] dp = new int[chs.length + 1];
+        dp[0] = 1;
+        dp[1] = chs[0] == '*' ? 9 : 1;
+        for (int i = 2; i <= chs.length; i++) {
+            char curr = chs[i - 1], prev = chs[i - 2];
+            long val = 0;
+            if (curr == '*') { // Warning: overflow!
+                val = 9L * dp[i - 1]; // blabla | *
+                if (prev == '1' || prev == '*')
+                    val += 9L * dp[i - 2]; // blabla | 1*
+                if (prev == '2' || prev == '*')
+                    val += 6L * dp[i - 2]; // blabla | 2*
+            } else if (curr == '0') {
+                if (prev == '1' || prev == '*')
+                    val += dp[i - 2]; // blabla | 10
+                if (prev == '2' || prev == '*')
+                    val += dp[i - 2]; // blabla | 20
+            } else {
+                val = dp[i - 1]; // blabla | curr
+                if (prev == '1' || prev == '*')
+                    val += dp[i - 2]; // blabla | 1curr
+                if ((prev == '2' || prev == '*') && curr <= '6')
+                    val += dp[i - 2]; // blabla | 2curr
+            }
+            dp[i] = (int) (val % MOD);
+        }
+        return dp[chs.length];
+    }
+}