leetcode习题集——30. 串联所有单词的子串

题目

给定一个字符串 s 和一些长度相同的单词 words。找出 s 中恰好可以由 words 中所有单词串联形成的子串的起始位置。

注意子串要与 words 中的单词完全匹配，中间不能有其他字符，但不需要考虑 words 中单词串联的顺序。

示例 1：
输入：
s = “barfoothefoobarman”,
words = [“foo”,“bar”]
输出：[0,9]
解释：
从索引 0 和 9 开始的子串分别是 “barfoor” 和 “foobar” 。
输出的顺序不重要, [9,0] 也是有效答案。

示例 2：
输入：
s = “wordgoodgoodgoodbestword”,
words = [“word”,“good”,“best”,“word”]
输出：[]

算法1

public class P30_SubstringwithConcatenationofAllWords {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> rlist = new ArrayList<>();
        boolean indexFlag = false;
        int count = 0;
        if(s==null||s.equals("")){
            return rlist;
        }
        if(words==null||words.length==0){
            return rlist;
        }
        int wordsLen = words[0].length();
        int[] flag = new int[words.length];
        int i = 0;
        while(i+wordsLen<=s.length()){
        	//按单词长度取子串
            String si = s.substring(i,i+wordsLen);
        	//如果子串在数组words[]中则标记
            if(findWordInArray(si,words,flag)==1){
                indexFlag =true;
                count++;
                //words数组被完全标记则输出正确结果
                if(judgeFlag(flag)==1){
                    rlist.add(i-(words.length-1)*wordsLen);
                    flag = new int[words.length];
                    i = i - (words.length-1)*wordsLen+1;
                    count = 0;
                    continue;
                }
                i += wordsLen;
            }else {
                if(indexFlag){
                //子串在words[]中，但超过数量
                    i = i+1-wordsLen*count;
                    indexFlag =false;
                    count = 0;
                }else {
                //子串不在words中
                    i += 1;
                }
				//指针向下移动，标记数组flag清零
                flag = new int[words.length];
            }
        }
        return rlist;
    }
    private int findWordInArray(String s,String[] words,int[] flag){
        for(int i = 0;i<words.length;i++){
            if(s.equals(words[i])&&flag[i]!=1){
                flag[i] = 1;
                return 1;
            }
        }
        return 0;
    }
    private int judgeFlag(int[] flag){
        for(int i = 0;i<flag.length;i++){
            if(flag[i]==0){
                return 0;
            }
        }
        return 1;
    }
}

思路：

1. 遍历s字符串，按单词长度取子串
2. 如果子串在数组words[]中则标记，直至所有word被标记，加入到list中
3. 子串在words[]中，但超过数量，则将指针回退到原来位置，再下移一个指针
4. 子串不在words[]中，下移一个指针

算法2

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> res = new ArrayList<>();
        if (s == null || words == null || words.length == 0) {
            return res;
        }
        int len = words[0].length();
        Map<String,Integer> map = new HashMap<>();
        for (String word : words) {
            map.put(word,map.containsKey(word) ? map.get(word) + 1 : 1);
        }
        for (int i = 0; i <= s.length() - len * words.length; i++) {
            Map<String,Integer> copy = new HashMap<>(map);
            for (int j = 0; j < words.length; j++) {
                String str = s.substring(i + j * len,i + j * len + len);
                if (copy.containsKey(str)) {
                    int count = copy.get(str);
                    if (count == 1) {
                        copy.remove(str);
                    } else {
                        copy.put(str, count - 1);
                    }
                    if (copy.isEmpty()) {
                        res.add(i);
                        break;
                    }
                } else {
                    break;
                }
            }
        }
        return res;
    }
}

思路：leetcode优秀解法。

1. 把words存在map中，key为words中的字符串，value为改key在words中的个数
2. 遍历s字符串，每找到一个map中的word就value-1，如果value为0则删去
3. 当map为空说明找到一个合适的解