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).
这道题让我们求串联所有单词的子串,就是说给定一个长字符串,再给定几个长度相同的单词,让我们找出串联给定所有单词的子串的起始位置,我目前的能力只是写出了一种可以通过168组数据的算法,还是的参考别人的算法思路和代码,这里先贴一下自己的求解的思路(为了不误人子弟,可以跳过下面一段)。
首先我们需要使用一个哈希表存取在words数组里面出现过的单个字符串key,在value中存放字符串在words数组中出现的次数,使用计数器count记录子串中出现的words里面的字符串的个数,当count = words.length时,成功找到一个子串。定义left指针从左开始一个字符一个字符遍历,right只向子串的右部,第二层循环每次从S中取出给定长度的子串与哈希表中的键值进行比较:
如果取出的子串是哈希表的键值:判断该键值对应的value>0? 如果大于0,说明该键值在left--right子串中没有出现,或者是在words数组中有重复,且目前允许重复。count++,right向右移动一定长度。否则说明left--right子串中不允许再出现该字符串了,这时break,跳出循环,重新初始化哈希表,count置0。
如果取出的子串不是哈希表的键值,说明出现了不允许出现的字符,这个连续的子串已经不符合要求了,跳出循环,重新初始化哈希表,count置0。
内层循环结束之后,说明重left开始的子串已经判断完成,如果count == words.length则说明找到了一个符合条件的子串,否则判断,count是否大于0,如果不大于0,说明哈希表没有被更改过没不需要重新初始化,否则初始化哈希表。
代码如下:
public class Solution { public List<Integer> findSubstring(String s, String[] words) { int wlen = words[0].length(); List<Integer> li = new ArrayList<Integer>(); if(s.length()/wlen < words.length) // 长度不足,直接返回 return li; HashMap<String,Integer> map = new HashMap<String,Integer>(); initValue(map,words); int slen = s.length(); int wordslen = wlen*words.length; for(int left = 0;left<=slen-wordslen;left++){ int count = 0; int right = left; String sub = s.substring(right,right+wlen); while( map.containsKey(sub) && map.get(sub)>0 ){ //对于每一个;left right向后判断子串是否符合条件 map.put( sub,map.get(sub)-1 ); count++; right += wlen; if(right + wlen>s.length()) break; sub = s.substring(right,right+wlen); } if(count == words.length) li.add(left); if(count>0){ map.clear(); initValue(map,words); } } return li; } public void initValue(HashMap map,String []words){ //初始化哈希表 for(int i=0;i<words.length;i++){ if( map.containsKey(words[i]) ){ map.put( words[i],(int)map.get(words[i])+1 ); } else{ map.put( words[i],1 ); } } } }
这种思路超时,后来查看别人的算法,才发现我们这是一个字符一个字符的遍历,而更为巧妙的方式是一个单词一个单词的遍历,感觉别人写的思路挺明晰的,这里引用一下[LeetCode] Substring with Concatenation of All Words 串联所有单词的子串的分析思路:
这道题还有一种O(n)时间复杂度的解法,设计思路非常巧妙,但是感觉很难想出来。这种方法不再是一个字符一个字符的遍历,而是一个词一个词的遍历,比如根据题目中的例子,字符串s的长度n为18,words数组中有两个单词(cnt=2),每个单词的长度len均为3,那么遍历的顺序为0,3,6,8,12,15,然后偏移一个字符1,4,7,9,13,16,然后再偏移一个字符2,5,8,10,14,17,这样就可以把所有情况都遍历到,我们还是先用一个哈希表m1来记录words里的所有词,然后我们从0开始遍历,用left来记录左边界的位置,count表示当前已经匹配的单词的个数。然后我们一个单词一个单词的遍历,如果当前遍历的到的单词t在m1中存在,那么我们将其加入另一个哈希表m2中,如果在m2中个数小于等于m1中的个数,那么我们count自增1,如果大于了,那么需要做一些处理,比如下面这种情况, s = barfoofoo, words = {bar, foo, abc}, 我们给words中新加了一个abc,目的是为了遍历到barfoo不会停止,那么当遍历到第二foo的时候, m2[foo]=2, 而此时m1[foo]=1,这是后已经不连续了,所以我们要移动左边界left的位置,我们先把第一个词t1=bar取出来,然后将m2[t1]自减1,如果此时m2[t1]<m1[t1]了,说明一个匹配没了,那么对应的count也要自减1,然后左边界加上个len,这样就可以了。如果某个时刻count和cnt相等了,说明我们成功匹配了一个位置,那么将当前左边界left存入结果res中,此时去掉最左边的一个词,同时count自减1,左边界右移len,继续匹配。如果我们匹配到一个不在m1中的词,那么说明跟前面已经断开了,我们重置m2,count为0,左边界left移到j+len,
代码如下:
public class Solution { public ArrayList<Integer> findSubstring(String S, String[] L) { ArrayList<Integer> res = new ArrayList<Integer>(); if(S==null || S.length()==0 || L==null || L.length==0) return res; HashMap<String,Integer> map = new HashMap<String,Integer>(); for(int i=0;i<L.length;i++) // 初始化哈希表,是每次判断过程中的标准 { if(map.containsKey(L[i])) { map.put(L[i],map.get(L[i])+1); } else { map.put(L[i],1); } } for(int i=0;i<L[0].length();i++) // l[0].length代表 L 中每个字符串的长度,因为要通过,每次偏移一个字符来实现遍历 { HashMap<String,Integer> curMap = new HashMap<String,Integer>(); // 心得哈希表是在每次向右遍历过程中动态变化的 int count = 0; int left = i; //left,right -->right 到达s的右侧,代表偏移一个字符,所需要的遍历结束 for(int j=i;j<=S.length()-L[0].length();j+=L[0].length()) { String str = S.substring(j,j+L[0].length()); if(map.containsKey(str)) //取出的子串如果在words中 则更新 动态变化的哈希表 { if(curMap.containsKey(str)) //存在该键值 curMap.put(str,curMap.get(str)+1); else curMap.put(str,1); //不存在该键值 if(curMap.get(str)<=map.get(str)) //子串中 str 键值代表的 value 没有达到饱和 count++; else { //如果str代表的键值达到饱和,说明连续的子串中出现了字符串的重复,需要跳过之前出现过的str,通过循环left while(curMap.get(str)>map.get(str)) //跳过其后的子串,更新curmap和count,并判断其后指定长度的子串是 //否是str,如果不是,则继续向右跳动指定长度,如果是,说明left后的子串left--right已经符合要求,达到了 == 刚好饱和 { String temp = S.substring(left,left+L[0].length()); if(curMap.containsKey(temp)) { curMap.put(temp,curMap.get(temp)-1); if(curMap.get(temp)<map.get(temp)) count--; } left += L[0].length(); } } if(count == L.length) //如果找到一个子串,left向右跳动指定长度,继续遍历。 { res.add(left); String temp = S.substring(left,left+L[0].length()); if(curMap.containsKey(temp)) curMap.put(temp,curMap.get(temp)-1); count--; left += L[0].length(); } } else //连续子串中出现了不允许出现的字符串,right之前的子串已经不可能符合条件,left直接跳到right+L[0].length() { curMap.clear(); count = 0; left = j+L[0].length(); } } } return res; } }