LeetCode——串联所有单词的子串 / 无重复字符的最长子串

1. 串联所有单词的子串

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

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

示例 1：

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

示例 2：

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

示例 3：

输入：s = “barfoofoobarthefoobarman”, words = [“bar”,“foo”,“the”]
输出：[6,9,12]

提示：

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

（1）直接法

• 借用Hashmap，利用两个HashMap
• 一个HashMap,map1存储words中：单词/单词出现次数（key为单词，value为单词出现次数）。
• 一个HashMap,map2用于从s中截取所有words串联的字符串
• 将以上从s中截取所有words串联的字符串按照单个word长度进行拆分
• 比较map1与map2是否相等
• 因为遍历和比较都是线性的，所以时间复杂度：O(n^2)

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> res = new ArrayList<>();
        if (s == null || s.length() == 0 || words.length == 0 || words == null)
            return res;
        
        HashMap<String, Integer> map = new HashMap<>();
        int one_word = words[0].length();       //单个word长度
        int word_num = words.length;            //word的个数
        int all_len = one_word * word_num;      //子串长度

        //存储单词words: key为单词，value为单词出现次数
        for (String word : words) {
            map.put(word, map.getOrDefault(word, 0) + 1);       
        }

        //截取所有单词串联的字符串
        for (int i = 0; i < s.length() - all_len + 1; i++) {
            //substring（x, y）:x, y分别为开始/结束位置，左闭右开，[ )
            String tmp = s.substring(i, i+all_len);
            HashMap<String,Integer> tmp_map = new HashMap<>();

            //所有单词串联的字符串，按照单个word长度拆分
            for(int j = 0; j < all_len; j += one_word) {
                String w = tmp.substring(j, j + one_word);
                //截取字符串出现次数，key为单词，value为单词出现次数
                tmp_map.put(w, tmp_map.getOrDefault(w, 0) + 1);
            }
            if (map.equals(tmp_map))
                res.add(i);
        }

        return res;
    }
}

（2）滑动窗口

• 在 s 维护着所有单词长度总和的一个长度队列

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> res = new ArrayList<>();
        HashMap<String, Integer> wordsMap = new HashMap<>();
        int one_word = words[0].length();       //单个word长度
        int word_num = words.length;            //word的个数
        int all_len = one_word * word_num;      //子串长度

        //为空 和 子串 > 主串，直接返回
        if (s == null || s.length() == 0 || words.length == 0 || words == null)
            return res;
        if(all_len > s.length())
            return res;

        //存储单词words: key为单词，value为单词出现次数
        for (String word : words) {
            wordsMap.put(word, wordsMap.getOrDefault(word, 0) + 1);       
        }

        // 只讨论从0，1，...， oneLen-1 开始的子串情况，
        // 每次进行匹配的窗口大小为 wordsLen，每次后移一个单词长度，由左右窗口维持当前窗口位置
        for (int i = 0; i < one_word; i++) {
            int left = i, right = i, count = 0;
            Map<String, Integer> subMap = new HashMap<>();

            // 右窗口不能超出主串长度
            while (right + one_word <= s.length()) {
                String word = s.substring(right, right + one_word);       // 得到一个单词
                right += one_word;            // 有窗口右移

                // words[]中没有这个单词，那么当前窗口肯定匹配失败，直接右移到这个单词后面
                if (!wordsMap.containsKey(word)) {
                    left = right;
                    subMap.clear();         // 窗口内单词统计map清空，重新统计
                    count = 0;              // 符合要求的单词数清0
                } else {
                // 统计当前子串中这个单词出现的次数
                    subMap.put(word, subMap.getOrDefault(word, 0) + 1);
                    ++count;
                    // 如果这个单词出现的次数大于words[]中它对应的次数，又由于每次匹配和words长度相等的子串
                    // 如 ["foo","bar","foo","the"]  "| foobarfoobar| foothe"
                    // 第二个bar虽然是words[]中的单词，但是次数抄了，那么右移一个单词长度后 "|barfoobarfoo|the"
                    // bar还是不符合，所以直接从这个不符合的bar之后开始匹配，也就是将这个不符合的bar和它之前的单词(串)全移出去
                    while (subMap.getOrDefault(word, 0) > wordsMap.getOrDefault(word, 0)) {
                        // 从当前窗口字符统计map中删除从左窗口开始到数量超限的所有单词(次数减一)
                        String w = s.substring(left, left + one_word);
                        subMap.put(w, subMap.getOrDefault(w, 0) - 1);
                        --count;
                        left += one_word;
                    }
                     // 当前窗口字符串满足要求
                    if (count == words.length) 
                        res.add(left);
                }
            }     
        }
        return res;
    }
}

2. 无重复字符的最长子串

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: s = “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。

示例 2:

输入: s = “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。

示例 3:

输入: s = “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。

示例 4:

输入: s = “”
输出: 0

提示：

• 0 <= s.length <= 5 * 104
• s 由英文字母、数字、符号和空格组成

（1）暴力

• 不论使用哪种方法，都需要判断当前字符是否已经出现在当前子串中，如果不使用哈希表，则额外需要O(n)的时间复杂度。
• 因此以下方法都默认使用哈希表来判断是否出现了重复字符。

class Solution {
    public int lengthOfLongestSubstring(String s) {
		int res = 0;
		Set<Character>  set = new HashSet<>();
		char[] str = s.toCharArray();
		for (int i = 0; i < str.length; i++) {
			int curRes = 0;
			for (int j = i; j < str.length; j++) {
				//如果存在重复字符，直接返回
				if (set.contains(str[j])) {
					set.clear();
					break;
				} else {
					set.add(str[j]);
					curRes += 1;
				}
				//每次跳出循环时计算当前子串长度
				res = Math.max(res, curRes);
			}
		}
		return res;
    }
}

（2）滑动窗口

• 暴力解法时间复杂度较高，会达到 O(n^2)，故而采取滑动窗口的方法降低时间复杂度
• 定义一个 map 数据结构存储 (k, v)，其中 key 值为字符，value 值为字符位置 +1，加 1 表示从字符位置后一个才开始不重复
• 我们定义不重复子串的开始位置为 start，结束位置为 end
• 随着 end 不断遍历向后，会遇到与 [start, end] 区间内字符相同的情况，此时将字符作为 key 值，获取其 value 值，并更新 start，此时 [start, end] 区间内不存在重复字符
• 无论是否更新 start，都会更新其 map 数据结构和结果 ans。
• 时间复杂度：O(n)
  
  
  
  
  
  

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int len = s.length();
        int max = 0;

        // map (k, v)，其中 key 值为字符，value 值为字符位置;
        Map<Character, Integer> map = new HashMap<>();  

        for (int start = 0, end = 0; end < len; end++) {
            char element = s.charAt(end);
            if (map.containsKey(element)) {
                //map.get(element)为第一次出现重复字符的位置
                //map.get()的地方进行+1操作,不加1则"abcabcbb"结果错误，本应3，输出4
                start = Math.max(map.get(element) + 1, start);
            }
            max = Math.max(max, end - start + 1);
            map.put(element, end);
        }
        return max;
    }
}