LeetCode：438. Find All Anagrams in a String

最近又開始刷LeetCode了，很多之前做過的題目這次很快地做出來了。但是，今天遇到了Find All Anagrams in a String這題，又琢磨了好久，可能是沒理解題目的精髓所在。

problem

Given a string s and a non-empty string p, find all the start indices of p’s anagrams in s.

Strings consists of lowercase English letters only and the length of both strings s and p will not be larger than 20,100.

The order of output does not matter.

Example 1:

Input:
s: "cbaebabacd" p: "abc"

Output:
[0, 6]

Explanation:
The substring with start index = 0 is "cba", which is an anagram of "abc".
The substring with start index = 6 is "bac", which is an anagram of "abc".

Example 2:

Input:
s: "abab" p: "ab"

Output:
[0, 1, 2]

Explanation:
The substring with start index = 0 is "ab", which is an anagram of "ab".
The substring with start index = 1 is "ba", which is an anagram of "ab".
The substring with start index = 2 is "ab", which is an anagram of "ab".

my bad solution

我的解特別low，使用HashMap，如下：

    public List<Integer> findAnagrams(String s, String p) {
        List<Integer> list = new ArrayList<>();
        if (s.length() < p.length())
            return list;
        int sum = 0;
        HashMap<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < p.length(); i++) {
            map.put(p.charAt(i), map.getOrDefault(p.charAt(i), 0) - 1);
        }
        A:
        for (int i = 0; i < s.length(); i++) {
            if (sum == p.length()) {
                map.put(s.charAt(i - p.length()), map.getOrDefault(s.charAt(i - p.length()), 0) - 1);
                map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
                for (char key : map.keySet()) {
                    if (map.get(key) != 0)
                        continue A;
                }
                list.add(i - p.length() + 1);
            } else {
                map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
                sum++;
                if (sum == p.length()) {
                    for (char key : map.keySet()) {
                        if (map.get(key) != 0)
                            continue A;
                    }
                    list.add(i - p.length() + 1);
                }
            }
        }
        return list;
    }

the great solution

下面給出一個很棒的解答，利用滑動窗口的方法：

public List<Integer> findAnagrams(String s, String p) {
    List<Integer> list = new ArrayList<>();
    if (s == null || s.length() == 0 || p == null || p.length() == 0) return list;
    int[] hash = new int[256]; //character hash
    //record each character in p to hash
    for (char c : p.toCharArray()) {
        hash[c]++;
    }
    //two points, initialize count to p's length
    int left = 0, right = 0, count = p.length();
    while (right < s.length()) {
        //move right everytime, if the character exists in p's hash, decrease the count
        //current hash value >= 1 means the character is existing in p
        if (hash[s.charAt(right++)]-- >= 1) count--; 

        //when the count is down to 0, means we found the right anagram
        //then add window's left to result list
        if (count == 0) list.add(left);

        //if we find the window's size equals to p, then we have to move left (narrow the window) to find the new match window
        //++ to reset the hash because we kicked out the left
        //only increase the count if the character is in p
        //the count >= 0 indicate it was original in the hash, cuz it won't go below 0
        if (right - left == p.length() && hash[s.charAt(left++)]++ >= 0) count++;
    }
    return list;
}

下面這種利用滑動窗口Sliding Window的方法非常較巧妙。

首先統計字符串p的字符個數，然後用兩個變量left和right表示滑動窗口的左右邊界，用變量count表示字符串p中需要匹配的字符個數。

然後開始循環，如果右邊界的字符已經在哈希表中了hash[s.charAt(right++)]-- >= 1，說明該字符在p中有出現，則count自減1，然後哈希表中該字符個數自減1，右邊界自加1。

如果此時count減爲0了，說明p中的字符都匹配上了，那麼將此時左邊界加入結果res中。

如果此時right和left的差爲p的長度，說明此時應該去掉最左邊的一個字符，我們看如果該字符在哈希表中的個數大於等於0，說明該字符是p中的字符。爲什麼呢，因爲上面我們有讓每個字符自減1，如果不是p中的字符，那麼在哈希表中個數應該爲0，自減1後就爲-1，所以這樣就知道該字符是否屬於p。如果我們去掉了屬於p的一個字符，count自增1。