LeetCode 30 Substring with Concatenation of All Words 解法为Hashmap

Substring with Concatenation of All Words

You are given a string, s, and a list of words, words, that are all of the same length. Find all starting indices of substring(s) in s that is a concatenation of each word in wordsexactly once and without any intervening characters.

For example, given:
s: "barfoothefoobarman"
words: ["foo", "bar"]

You should return the indices: [0,9].
(order does not matter).

解题思路：首先，理解题意很重要。由于我之前没有理解题意，靠测试用例理解，走了不少弯路。题意是返回字符串中的字符串片段，这样的组合涵盖words数组的每个字符串。若words中包含重复项，字符串组合中也应当有重复项。比如：wordgoodgoodgoodbestword，{"word","good","best","good"}  返回 8,就是从第8个起的子串涵盖words数组。

在这里，得以复习hashmap，并利用数组条件，减少使用map接口的频率，从而降低时间消耗。

由于存在重复项的问题，为此，我们设立两个map，一个记录words的字符串出现次数，一个作为临时map，记录每次截取的字符串个数。若出现不是第一个map的子串则跳过，若扫描个数出现大于第一个map的个数则跳过。若完成遍历的时候，计数与words长度相同，不需要map的相等判断，直接可以判断符合条件。因为，不符合的情况，已经全部被过滤。

public List<Integer> findSubstring(String s, String[] words) {
		 int len = s.length();
		 int wlen = words.length;
		 int slen =words[0].length();
		 int end = len-wlen*slen;
		 //判断是否都满足子串数组
		 HashMap<String, Integer> map = new HashMap<String, Integer>();
		 HashMap<String, Integer> map1 = new HashMap<String, Integer>();//临时map
		 List<Integer> ls =new ArrayList<Integer>();
		 for (int i = 0; i < wlen; i++) {
			 if(map.containsKey(words[i])){
				 map.put(words[i], map.get(words[i])+1);
			 }else{
				 map.put(words[i], 1); 
			 }
		}
		 int i=0;
		 while(i<=end){
			 String str = s.substring(i, i+slen);
				if(map.containsKey(str)){
					//判断满足出现的组合contain
					 if(map1.containsKey(str)){
						 map1.put(str, map1.get(str)+1);
					 }else{
						 map1.put(str, 1); 
					 }
					int t =i+slen;
					int j;
                  for ( j = 1; j < wlen; j++) {
                	  if(t+slen>len){
                		  return ls;
                	  }
                	  String str1 = s.substring(t, t+slen);
                	  if(map.containsKey(str1)){
                		  if(map1.containsKey(str1)){
     						 map1.put(str1, map1.get(str1)+1);
     					 }else{
     						 map1.put(str1, 1); 
     					 }	  
                	  }else{
                		  break;
                	  }
                	  t+=slen;
                	  if(map1.get(str1)>map.get(str1)){//这个
                		  break;
                	  }
				}
            	  if(j==wlen){//这个
                	  ls.add(i);
                  }
			}
		i++;
  	  map1.clear();
		 }
		return ls;     
	    }

上述对算法的优化参考自http://www.cnblogs.com/zhaolizhen/p/SubCon.html

这里，再给出一个discuss上的O(n)的解法：

public List<Integer> findSubstring(String S, String[] L) {
    List<Integer> res = new ArrayList<>();
    if (L.length == 0) {
        return res;
    }
    int len = L[0].length();
    int num = L.length;
    if (len * num > S.length()) {
        return res;
    }

    //histogram of words in L
    HashMap<String, Integer> dic = new HashMap<>();
    for (String s : L) {
        if (dic.containsKey(s)) {
            dic.put(s, dic.get(s) + 1);
        } else {
            dic.put(s, 1);
        }
    }

    //the word that starts from i in S
    String[] sDic = new String[S.length() - len + 1];
    for (int i = 0; i < sDic.length; i++) {
        String sub = S.substring(i, i + len);
        if (dic.containsKey(sub)) {
            sDic[i] = sub;
        } else {
            sDic[i] = "";
        }
    }

    //traverse in order of 0,0+len,...,1,1+len,...len-1,len-1+len...therefore it is O(n) despite of two loops
    for (int i = 0; i < len; i++) {

        //start of concatenation
        int start = i;
        //number of words found
        int found = 0;
        //dynamic word histogram of words in substring(start,j);
        HashMap<String, Integer> tempDic = new HashMap<>();
        for (int j = i; j <= S.length() - len; j = j + len) {
            String word = sDic[j];
            if (word.equals("")) {
                tempDic = new HashMap<>();
                start = j + len;
                found = 0;
                continue;
            } else {
                if (!tempDic.containsKey(word)) {
                    tempDic.put(word, 1);
                } else {
                    tempDic.put(word, tempDic.get(word) + 1);
                }
                found++;
            }
            //if we over-count a word, delete the first word in front. Also delete the words before that.
            if (tempDic.get(word) > dic.get(word)) {
                while (!sDic[start].equals(word)) {
                    tempDic.put(sDic[start], tempDic.get(sDic[start]) - 1);
                    start += len;
                    found--;
                }
                tempDic.put(word, tempDic.get(word) - 1);
                start += len;
                found--;
            }
            if (found == num) {
                res.add(start);
            }

        }

    }
    return res;
}