Question

438. Find All Anagrams in a String

Solution

Topic: Give two strings, s and p, find the position of P in s, the character in P string is out of order, ab=ba

Idea: At first, I want to find the full arrangement of p, save it in set, traverse s, if it appears in set, the first character position in S is saved in the result, and finally return the result. This idea runs out of time. Maybe the full permutation timed out.

Idea 2: First, the number of characters in p and the number of occurrences of characters are counted out to save in map, and then traverse s. This idea and 169. Majority Element - LeetCode The innovative solutions mentioned in this paper are similar.

Java implementation:

public List<Integer> findAnagrams(String s, String p) {
    List<Integer> ans = new ArrayList<>();
    if (s.length() <= p.length()) return ans;

    // Construct map and initialize target
    Map<Character, Bo> map = new HashMap<>();
    for (char tmp : p.toCharArray()) {
        Bo bo = map.get(tmp);
        if (bo == null) {
            bo = new Bo();
            map.put(tmp, bo);
        }
        bo.target++;
    }

    // Preceding p.length()
    for (int i = 0; i < p.length(); i++) {
        char cur = s.charAt(i);
        Bo bo = map.get(cur);
        if (bo != null) {
            bo.cur++;
        }
    }
    if (allOne(map)) ans.add(0);

    for (int i = p.length(); i < s.length(); i++) {
        char cur = s.charAt(i);
        if (map.get(cur) != null) map.get(cur).cur++;
        char last = s.charAt(i - p.length());
        if (map.get(last) != null) map.get(last).cur--;
        if (allOne(map)) ans.add(i - p.length() + 1);
    }

    return ans;
}

public boolean allOne(Map<Character, Bo> map) {
    for (Map.Entry<Character, Bo> entry : map.entrySet()) {
        if (entry.getValue().cur != entry.getValue().target) return false;
    }
    return true;
}

class Bo {
    int cur; // Current number
    int target; // Target number

    public Bo() {
        this(0, 0);
    }

    public Bo(int cur, int target) {
        this.cur = cur;
        this.target = target;
    }
}

Discuss

Appreciate what others have written. The following two questions are written in the same way. Record them.

https://leetcode.com/problems/find-all-anagrams-in-a-string/discuss/92015/ShortestConcise-JAVA-O(n)-Sliding-Window-Solution

https://leetcode.com/problems/minimum-window-substring/discuss/26808/here-is-a-10-line-template-that-can-solve-most-substring-problems

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;
}

public List<Integer> findAnagrams(String s, String p) {

    char[] ptrn = p.toCharArray();
    char[] str = s.toCharArray();
    
    int[] w = new int[26];
    
    for(char c : ptrn) w[c - 'a']++;
    
    int start = 0;
            
    List<Integer> result = new LinkedList<>();
    
    for(int i = 0; i<str.length; i++){
        int cIndex = str[i] - 'a';

        w[cIndex]--;
        // the crucial bit, if we have seen the character too many times 
        // or it is a character that is not in the pattern, rewind the starting index
        while(w[cIndex] < 0){
            w[str[start] - 'a']++;
            start++;
        }
        
        if(i - start + 1 == ptrn.length){
            result.add(start);
            w[str[start] - 'a']++;
            start++;
        }
    }
    

    return result;
}