(Java)LeetCode-30. 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 words exactly 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).

这道题Hard模式，比较复杂，又没有用到很经典的算法，卡在这道题很长时间了。

首先比较直观的解法

package datastru;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Solution {
public List<Integer> findSubstring(String s, String[] words) {
Map<String, Integer> map = new HashMap<String, Integer>();
for(String word : words){
if(map.containsKey(word)){
map.put(word, map.get(word)+1);
}else{
map.put(word, 1);
}
}
List<Integer> result = new ArrayList<Integer>();
int len = words[0].length();
int cal_len = s.length() - words.length * len;

for(int i = 0; i <= cal_len; i++){
Map<String, Integer> copy_map = new HashMap<String, Integer>(map);
int temp = i;
String sub_s = s.substring(temp,temp+len);
while(copy_map.containsKey(sub_s)){
if(copy_map.get(sub_s) == 1){
copy_map.remove(sub_s);
}else{
copy_map.put(sub_s, copy_map.get(sub_s)-1);
}
temp = temp + len;
if(temp+len<=s.length()){
sub_s = s.substring(temp,temp+len);
}else{
break;
}
}
if(copy_map.isEmpty()){
result.add(i);
}
}

return result;
}

public static void main(String[] args){
Solution sol = new Solution();
String s = "wordgoodgoodgoodbestword";
String[] words = {"word","good","best","good"};
List<Integer> list= sol.findSubstring(s, words);
System.out.println(list);
}
}

这样做超时了，因为有很多重复的检查，下面这种做法是在discuss里面看到的，去掉了这种重复，厉害厉害。我就没有自己写了，直接复制如下。

idea is use hashmap and slide window.
the single word's length is k , than we have k kinds of windows.
for each kind of window, we slide it right k length
if find a new word not belongs to dictionary, then put start at it's right and clean the hashmap COPY

public class Solution {
public List<Integer> findSubstring(String s, String[] L) {
List<Integer> list = new ArrayList<Integer>();
if(s==null|| s==""||L==null||L[0].length()==0)
return list;
HashMap<String, Integer> map = new   HashMap<String ,Integer>();
int len=L[0].length();
int k = len;
int count = L.length;
for (String  tmp : L) {
if(!map.containsKey(tmp)) {
map.put(tmp, 1);
}else
map.put(tmp,map.get(tmp)+1);
}

String curr = "";
int start = 0;
int x = 0;
for (int i = 0; i <k; i++) {      // there are k kind of slide window, and slide right k each time
HashMap<String , Integer> copy = new HashMap<>();
start = i;
for(int j =i; j+k<=s.length(); j = j + k ){     // slide window, the window's length is k*count
curr = s.substring(j,j+k);
if(map.containsKey(curr)){      //curr belongs to dictionary
addright(copy,curr);
if(j+k - start > k*count){      // window size exceed k*count
removeleft(copy,  s.substring(start,start+k));
start = start + k;
}
if(j+k-start == k*count && copy.equals(map))
list.add(start);
}else{          // dictionary don't include curr, skip it

copy.clear();
start = j + k;
}
}
}
return list;

}

public void addright(HashMap<String,Integer> copy, String curr){
if(copy.containsKey(curr)){        // curr l in copy
copy.put(curr,copy.get(curr)+1);
}else{      // curr do not exist in copy, but it belongs to dictionary
copy.put(curr,1);
}
}

public void removeleft(HashMap<String,Integer> copy, String curr){
int x = copy.get(curr);
if(x==1)   copy.remove(curr);
else    copy.put(curr,x-1);
}
}

哎，就这样吧~无聊的题