[LintCode] Substring Anagrams

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 40,000.

The order of output does not matter.

 

Example

Given s = "cbaebabacd" p = "abc"

return [0, 6]

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".




Solution 1.  
1. Store all characters' frequencies of p in array pMap.
2. Similarly with sliding window problems, scan each character
in s and add it to a queue and update its frequency in array sMap.
3. When the queue's size equals to p's length, compare if pMap's
values are the same with sMap's. If they are, we've found a start
index of p's anagram.
4. Remove the head character from the queue, then repeat the above
steps until we've checked all s' characters.

Runtime: O(n) * O(26) -- O(n),  O(n) for iterating through both s and p;
         O(26) for checking if found a substring anagram.
Space: O(26) * 2 + O(m) -- O(m), m is the length string p.

public class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        List<Integer> indices = new ArrayList<Integer>();
        if(s == null || s.length() < p.length()){
            return indices;
        }
        int[] sMap = new int[26];
        int[] pMap = new int[26];
        for(int i = 0; i < p.length(); i++){
            pMap[p.charAt(i) - 'a']++;
        }
        Queue<Character> queue = new LinkedList<Character>();
        int index = 0; 
        while(index < s.length()){
            queue.add(s.charAt(index));
            sMap[s.charAt(index) - 'a']++;
            if(queue.size() == p.length()){
                if(isAnagrams(sMap, pMap)){
                    indices.add(index - p.length() + 1);
                }
                sMap[queue.poll() - 'a']--;
            }
            index++;
        }
        return indices;
    }
    private boolean isAnagrams(int[] sMap, int[] pMap){
        for(int i = 0; i < sMap.length; i++){
            if(sMap[i] != pMap[i]){
                return false;
            }
        }
        return true;
    }
}

 

Solution 2.

Can we do better?  

For runtime, we've already acheived BCR, so can we optimize the constance?

For space efficiency, we used O(m) extra space in Solution 1. Is it possible for us to only use O(1) space? 

 

We sure can.

In solution 1, we used 2 arrays of size 26 and 1 queue of max size m(m is the length of p);

we can reduce the space usage to only 1 array of size 26.  

The key idea here is that we initalizethis array to be p's characters appearance times.

Then we modify its element and restore it as we scan through s.

If we find a match, decrease that matched character's apperance times by 1.

To simulate the queue used in solution 1, we introduce a new variable matched that keeps track

of how many characters we've matched so far.  This matched variable also saves us from 

the O(26) anagram check each time we've found a substring of length m in solution 1.

 

public class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        List<Integer> ans = new ArrayList <Integer>();
        int[] sum = new int[26];
        int plength = p.length(), slength = s.length();
        //store all characters' frequencies from p
        for(char c : p.toCharArray()){
            sum[c - 'a']++;
        }
        int start = 0, end = 0, matched = 0;
        while(end < slength){
            //find a character match
            if(sum[s.charAt(end) - 'a'] >= 1){
                matched++;
            }
            sum[s.charAt(end) - 'a']--;
            end++;
            //if find all needed matches, add index start to final result
            if(matched == plength) {
                ans.add(start);
            }
            //sliding window principle
            if(end - start == plength){
                //found a match at index start before need to decrease matched 
                //by 1 as s.charAt(start) will be out of the sliding window
                if(sum[s.charAt(start) - 'a'] >= 0){
                    matched--;
                }
                //restore the frequency of character s.charAt(start) for later check
                sum[s.charAt(start) - 'a']++;
                start++;
            }
        }
        return ans;
    }
}

 

 Rewrite of solution 2 to make it have the same code structure with Minimum Window Substring.

public class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        List<Integer> ans = new ArrayList <Integer>();
        int[] sum = new int[26];
        int plength = p.length(), slength = s.length();
        //store all characters' frequencies from p
        for(char c : p.toCharArray()){
            sum[c - 'a']++;
        }
        int start = 0, end = 0, matched = 0;
        for(end = 0; end < slength; end++) {
            //find a character match
            if(sum[s.charAt(end) - 'a'] > 0){
                matched++;
            }
            sum[s.charAt(end) - 'a']--;
            //if find all needed matches, add index start to final result
            if(matched == plength) {
                ans.add(start);
            }
            //sliding window principle
            if(end - start  + 1 == plength){
                //restore the frequency of character s.charAt(start) for later check
                sum[s.charAt(start) - 'a']++;
                //found a match at index start before; need to decrease matched 
                //by 1 as s.charAt(start) will be out of the sliding window
                if(sum[s.charAt(start) - 'a'] > 0){
                    matched--;
                }
                start++;
            }            
        }
        return ans;
    }
}

Related Problem
Minimum Window Substring