力扣刷题Day2 --- 3.无重复字符的最长子串（滑动窗口）

2021.5.4

题目：

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

难度：中等

示例：

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

力扣题目地址：

https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/

解题思路：

本文思路摘自力扣大佬思路

第一步：解法一

我们最开始肯定是先想到用一个函数去判断子串是否有重复，然后再用一个函数循环穷举所有子串，找出最长子串。思路是没问题的，但是三个for循环在数据大的时候会超时。

图解：i其实相当于左指针，j相当于右指针。

public int lengthOfLongestSubstring(String s) {
    int n = s.length();
    int ans = 0;//保存当前得到满足条件的子串的最大值
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n+1; j++) //之所以 j< n+1，是因为我们子串是 [i,j),左闭右开.就像上面图片一样，子串最长为3，所以j需要比它多1才能表示出来
            if (allUnique(s, i, j)) ans = Math.max(ans, j - i); //更新 ans
    return ans;
}

public boolean allUnique(String s, int start, int end) {
    Set<Character> set = new HashSet<>();//初始化 hash set
    for (int i = start; i < end; i++) {//遍历每个字符
        Character ch = s.charAt(i);
        if (set.contains(ch)) return false; //判断字符在不在 set 中
        set.add(ch);//不在的话将该字符添加到 set 里边
    }
    return true;
}

第二步：解法二

遗憾的是上边的算法没有通过 leetCode，时间复杂度太大，造成了超时。我们怎么来优化一下呢？

上边的算法中，我们假设当 i 取 0 的时候，

• j 取 1，判断字符串 str[0,1) 中有没有重复的字符。
• j 取 2，判断字符串 str[0,2) 中有没有重复的字符。
• j 取 3，判断字符串 str[0,3) 中有没有重复的字符。
• j 取 4，判断字符串 str[0,4) 中有没有重复的字符。

做了很多重复的工作，因为如果 str[0,1) 中没有重复的字符，我们不需要再判断整个字符串 str[0,2) 中有没有重复的字符，而只需要判断 str[2] 在不在 str[0,1) 中，不在的话，就表明 str[0,2) 中没有重复的字符。如果在的话，那么 str[0,3) ，str[0,4) ，str[0,5) 一定有重复的字符，所以此时后边的 j 也不需要继续增加了。i ++ 进入下次的循环就可以了。

此外，我们的 j 也不需要取 j + 1，而只需要从当前的 j 开始就可以了。

综上，其实整个关于 j 的循环我们完全可以去掉了，此时可以理解变成了一个「滑动窗口」。

整体就是橘色窗口在依次向右移动。

判断一个字符在不在字符串中，我们需要可以遍历整个字符串，遍历需要的时间复杂度就是 O（n），加上最外层的 i 的循环，总体复杂度就是 O（n²）。我们可以继续优化，判断字符在不在一个字符串，我们可以将已有的字符串存到 Hash 里，这样的时间复杂度是 O（1），总的时间复杂度就变成了 O（n）。

public class Solution {
    public int lengthOfLongestSubstring(String s) {
        int n = s.length();
        Set<Character> set = new HashSet<>();
        int ans = 0, i = 0, j = 0;
        while (i < n && j < n) {
            if (!set.contains(s.charAt(j))){
                set.add(s.charAt(j++));
                ans = Math.max(ans, j - i);
            }
            else {
                set.remove(s.charAt(i++));
            }
        }
        return ans;
    }
}

时间复杂度：在最坏的情况下，while 循环中的语句会执行 2n 次，例如 abcdefgg，开始的时候 j 一直后移直到到达第二个 g 的时候固定不变 ，然后 i 开始一直后移直到 n ，所以总共执行了 2n 次，时间复杂度为 O（n）。

空间复杂度：和上边的类似，需要一个 Hash 保存子串，所以是 O（min（m，n））。到这里，我们的解法就已经算凑合了，但是还有可以进行优化的地方，且看解法三

第三步：解法三

继续优化，我们看上边的算法的一种情况。

当 j 指向的 c 存在于前边的子串 abcd 中，此时 i 向前移到 b ,此时子串中仍然含有 c，还得继续移动，所以这里其实可以优化。我们可以一步到位，直接移动到子串 c 的位置的下一位！这种想法和在串的模式匹配里面用到的思想是很相似的。

实现这样的话，我们将 set 改为 map ，将字符存为 key ，将对应的下标存到 value 里就实现了。这里的i代表左指针，j代表右指针

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int n=s.length();
        int ans=0;
        Map<Character,Integer> map=new HashMap<>();
        for(int i=0,j=0;j<n;j++){
            if(map.containsKey(s.charAt(j))){
                i=Math.max(map.get(s.charAt(j))+1,i); //当前字符包含在当前有效的子段中，那么我们就需要更新左指针。（比如像上面图片一样，j指针指向c的时候（abcdc），当前字符在有效字段中，那么我们需要把i指针移动到第一个c的右边，也就是d的位置，所以是s.charAt(j))+1）
            }
            ans=Math.max(ans,j-i+1);
            map.put(s.charAt(j),j);
        }
        return ans;
    }
}

与解法二相比

由于采取了 i 跳跃的形式，所以 map 之前存的字符没有进行 remove ，所以 if 语句中进行了Math.max ( map.get ( s.charAt ( j ) ) , i )，要确认得到的下标不是 i 前边的。所以取得范围在[i，j]之间。

还有个不同之处是 j 每次循环都进行了自加 1 ，因为 i 的跳跃已经保证了 str[ i , j] 内没有重复的字符串，所以 j 直接可以加 1 。而解法二中，要保持 j 的位置不变，因为不知道和 j 重复的字符在哪个位置。

最后个不同之处是， ans 在每次循环中都进行更新，因为 ans 更新前 i 都进行了更新，已经保证了当前的子串符合条件，所以可以更新 ans 。而解法二中，只有当当前的子串不包含当前的字符时，才进行更新。

时间复杂度：我们将 2n 优化到了 n ，但最终还是和之前一样，O（n）。

空间复杂度：也是一样的，O（min（m，n)）。