leetcode-030-串联所有单词的子串

题目及测试

package pid030;
/*30. 串联所有单词的子串
给定一个字符串 s 和一个字符串数组 words。 words 中所有字符串 长度相同。

 s 中的 串联子串 是指一个包含  words 中所有字符串以任意顺序排列连接起来的子串。

例如，如果 words = ["ab","cd","ef"]， 那么 "abcdef"， "abefcd"，"cdabef"， "cdefab"，"efabcd"， 和 "efcdab" 都是串联子串。 "acdbef" 不是串联子串，因为他不是任何 words 排列的连接。
返回所有串联字串在 s 中的开始索引。你可以以 任意顺序 返回答案。

 

示例 1：

输入：s = "barfoothefoobarman", words = ["foo","bar"]
输出：[0,9]
解释：因为 words.length == 2 同时 words[i].length == 3，连接的子字符串的长度必须为 6。
子串 "barfoo" 开始位置是 0。它是 words 中以 ["bar","foo"] 顺序排列的连接。
子串 "foobar" 开始位置是 9。它是 words 中以 ["foo","bar"] 顺序排列的连接。
输出顺序无关紧要。返回 [9,0] 也是可以的。
示例 2：

输入：s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
输出：[]
解释：因为 words.length == 4 并且 words[i].length == 4，所以串联子串的长度必须为 16。
s 中没有子串长度为 16 并且等于 words 的任何顺序排列的连接。
所以我们返回一个空数组。
示例 3：

输入：s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
输出：[6,9,12]
解释：因为 words.length == 3 并且 words[i].length == 3，所以串联子串的长度必须为 9。
子串 "foobarthe" 开始位置是 6。它是 words 中以 ["foo","bar","the"] 顺序排列的连接。
子串 "barthefoo" 开始位置是 9。它是 words 中以 ["bar","the","foo"] 顺序排列的连接。
子串 "thefoobar" 开始位置是 12。它是 words 中以 ["the","foo","bar"] 顺序排列的连接。
 

提示：

1 <= s.length <= 104
1 <= words.length <= 5000
1 <= words[i].length <= 30
words[i] 和 s 由小写英文字母组成

*/

import java.util.Arrays;
import java.util.List;

public class main {
	
	public static void main(String[] args) {
		String [] testTable = {"foo","bar"};
		String [] testTable2 = {"foo","bar","the"};
		String [] testTable3 = {"word","good","best","good"};
		test("wordgoodgoodgoodbestword", testTable3);
		test("barfoothefoobarman", testTable);
		test("barfoofoobarthefoobarman", testTable2);
		
	}
		 
	private static void test(String ito,String[] ito2) {
		Solution solution = new Solution();
		List<Integer> rtn;
		long begin = System.currentTimeMillis();
		System.out.println(ito);
		System.out.println(Arrays.toString(ito2));
		//开始时打印数组
		
		rtn= solution.findSubstring(ito,ito2);//执行程序
		long end = System.currentTimeMillis();	
		
		System.out.println("rtn=" );
		for(int i=0;i<rtn.size();i++){
			System.out.print(rtn.get(i)+" ");
		}
		System.out.println();
		System.out.println("耗时：" + (end - begin) + "ms");
		System.out.println("-------------------");
	}

}

解法1（成功，70ms，较快）

使用回溯的思想，先遍历words数组，获取每个单词和对应的个数。（之所以要这样，是因为如果不去重，会超时，100个ab会有2^100的时间复杂度）

然后对字符串s，生成boolean[][] dict数组，对应s的每个下标开始，是否与wordsNew数组的单词对应

然后进行回溯，对每个下标，进行dfs，碰到dict[index][i]为true的，wordsNum[i]--，如果回溯到wordsNum全为0，代表全部对应

package pid030;

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

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
    	List<Integer> result = new ArrayList<Integer>();
    	int length = s.length();
    	int size = words.length;
    	if(size == 0){
    		return result;
    	}
    	int perLength = words[0].length();
    	if(length < perLength * size){
    		return result;
    	}
    	Map<String, Integer> wordMap = new HashMap<String, Integer>();
    	for(String word:words){
    		if(wordMap.containsKey(word)){
    			wordMap.put(word, wordMap.get(word)+1);
    		}else{
    			wordMap.put(word, 1);
    		}
    	}
    	String[] wordsNew = new String[wordMap.keySet().size()];
    	int[] wordsNum = new int[wordMap.keySet().size()];
    	int sizeNew = wordsNew.length;
    	int n = 0;
    	for(String word:wordMap.keySet()){
    		wordsNew[n] = word;
    		wordsNum[n] = wordMap.get(word);
    		n++;
    	}
    	
    	boolean[][] dict = new boolean[length][sizeNew];
    	boolean eql = false;
    	//判断从s的i开始，与word[j]是否匹配
    	for(int i=0;i<=length-perLength;i++){
    		for(int j=0;j<sizeNew;j++){
    			eql = true;
    			for(int k=0;k<perLength;k++){
    				if(s.charAt(i+k) != wordsNew[j].charAt(k)){
    					eql = false;
    					break;
    				}
    			}
    			dict[i][j] = eql;
    		}
    	}
    	for(int i=0;i<=length-perLength*size;i++){
    		boolean subS = dfs(s, words, dict, wordsNum, i);
    		if(subS){
    			result.add(i);
    		}
    	}
    	return result;
    }
    
    private boolean dfs(String s,String[] words,
    		boolean[][] dict,int[] wordsNum,int index){
    	int adapt = 0;
    	for(int i=0;i<wordsNum.length;i++){
    		if(wordsNum[i] == 0){
    			adapt++;
    			continue;
    		}
    		if(dict[index][i]){
    			wordsNum[i]--;
    			boolean result = dfs(s, words, dict, wordsNum, index+words[i].length());
    			wordsNum[i]++;
    			if(result){
    				return true;
    			}
    		}
    	}
    	if(adapt == wordsNum.length){
    		return true;
    	}else{
    		return false;
    	}
    }
}

解法2（别人的）

此题是「438. 找到字符串中所有字母异位词」的进阶版。不同的是第 438 题的元素是字母，而此题的元素是单词。可以用类似「438. 找到字符串中所有字母异位词的官方题解」的方法二的滑动窗口来解这题。

记 words 的长度为 m，words 中每个单词的长度为 n，s 的长度为 ls。首先需要将 s 划分为单词组，每个单词的大小均为 n （首尾除外）。这样的划分方法有 n 种，即先删去前 i （i = 0 ∼n−1）个字母后，将剩下的字母进行划分，如果末尾有不到 n 个字母也删去。对这 n 种划分得到的单词数组分别使用滑动窗口对 words 进行类似于「字母异位词」的搜寻。

划分成单词组后，一个窗口包含 s 中前 m 个单词，用一个哈希表 differ 表示窗口中单词频次和 words 中单词频次之差。初始化 differ 时，出现在窗口中的单词，每出现一次，相应的值增加 1，出现在 words 中的单词，每出现一次，相应的值减少 1。然后将窗口右移，右侧会加入一个单词，左侧会移出一个单词，并对 differ 做相应的更新。窗口移动时，若出现 differ 中值不为 0 的键的数量为 0，则表示这个窗口中的单词频次和 words 中单词频次相同，窗口的左端点是一个待求的起始位置。划分的方法有 n 种，做 n 次滑动窗口后，即可找到所有的起始位置。
 

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> res = new ArrayList<Integer>();
        int m = words.length, n = words[0].length(), ls = s.length();
        for (int i = 0; i < n; i++) {
            if (i + m * n > ls) {
                break;
            }
            Map<String, Integer> differ = new HashMap<String, Integer>();
            for (int j = 0; j < m; j++) {
                String word = s.substring(i + j * n, i + (j + 1) * n);
                differ.put(word, differ.getOrDefault(word, 0) + 1);
            }
            for (String word : words) {
                differ.put(word, differ.getOrDefault(word, 0) - 1);
                if (differ.get(word) == 0) {
                    differ.remove(word);
                }
            }
            for (int start = i; start < ls - m * n + 1; start += n) {
                if (start != i) {
                    String word = s.substring(start + (m - 1) * n, start + m * n);
                    differ.put(word, differ.getOrDefault(word, 0) + 1);
                    if (differ.get(word) == 0) {
                        differ.remove(word);
                    }
                    word = s.substring(start - n, start);
                    differ.put(word, differ.getOrDefault(word, 0) - 1);
                    if (differ.get(word) == 0) {
                        differ.remove(word);
                    }
                }
                if (differ.isEmpty()) {
                    res.add(start);
                }
            }
        }
        return res;
    }
}