最长不含重复字符的子字符串

一、需求

• 请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。

示例 1:

输入: "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:

输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:

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

二、动态规划+哈希表

2.1  思路分析

1. 定义状态dp[j]表示以字符s[j]为结尾的"最长不含重复字符的子字符串的最大长度"，每个状态的起点满足2中所描述的；
2. 固定右边界j，设字符s[j]左边距离最近的相同字符为s[i]，即s[i] = s[j]；
3. 关于转移方程，①dp[j-1] < j - i时，dp[j] = dp[j-1] + 1；②dp[j-1] >= j - i时，dp[j] = j - i；
4. 这个转移方程，更像是找规律，比如字符串为"1234"时，i 此时都不存在，故这种情况初始化 i 为负值，满足情况①；当字符串为"1001"时，当i = 0，j = 3时，满足①；当字符串为"1101"时，满足②相等的情况；当字符串为"1233"时，满足②大于的情况；

2.2  代码实现

/*
getOrDefault(key,default)，HashMap中的一个方法，若集合中存在key，那么就返回对应的
value值，否则返回default
*/
class Solution {
    public int lengthOfLongestSubstring(String s) {
        Map<Character,Integer> hm = new HashMap<>();
        int res = 0;
        if(s == null || s.length() == 0) return res;
        int[] dp = new int[s.length()];
        dp[0] = 1;
        hm.put(s.charAt(0),0);
        for(int j = 1; j < s.length(); j++) {
            //map中没有key，则返回设置的-1，有则返回key对应的value
            int i = hm.getOrDefault(s.charAt(j),-1);
            if(dp[j-1] < j-i) {
                dp[j] = dp[j-1] + 1;
            } else {
                dp[j] = j - i;
            }
            //更新hm值
            hm.put(s.charAt(j),j);
            res = Math.max(res,dp[j]);
        }
        return Math.max(res,1);
    }
}

2.3  复杂度分析

• 时间复杂度为O(N)，N为字符串的长度；
• 空间复杂度为O(N)，dp数组占用O(N)大小的额外空间，而HashMap集合最多存储128个字节，即最大O(128)，故总体空间复杂度为O(N)；

三、动态规划+哈希表优化

3.1  思路分析

1. 因为上述方法中dp[j]只与dp[j-1]及变量i，j有关，因此可用变量代替，从而节省空间，使得空间复杂度为O(1)；

3.2  代码实现

/*
getOrDefault(key,default)，HashMap中的一个方法，若集合中存在key，那么就返回对应的
value值，否则返回default
*/
class Solution {
    public int lengthOfLongestSubstring(String s) {
        Map<Character,Integer> hm = new HashMap<>();
        int res = 0;
        int tmp = 0;;
        for(int j = 0; j < s.length(); j++) {
            int i = hm.getOrDefault(s.charAt(j),-1);
            tmp = tmp < j-i ? tmp + 1 : j - i;
            //更新hm值
            hm.put(s.charAt(j),j);
            res = Math.max(res,tmp);
        }
        return res;
    }
}

四、动态规划+线性遍历

4.1  思路分析

1. 这个方法和上面区别就是使用线性遍历来寻找距离字符s[j]最近的那个索引 i ，就是当遍历到s[j]时，初始化索引 i = j - 1，然后向左遍历 i ，一直到 s[i] = s[j]；

4.2  代码实现

/*
getOrDefault(key,default)，HashMap中的一个方法，若集合中存在key，那么就返回对应的
value值，否则返回default
*/
class Solution {
    public int lengthOfLongestSubstring(String s) {
        Map<Character,Integer> hm = new HashMap<>();
        int res = 0;
        int tmp = 0;;
        for(int j = 0; j < s.length(); j++) {
            int i = j - 1;
            while(i >= 0 && s.charAt(i) != s.charAt(j)) i--;
            tmp = tmp < j-i ? tmp + 1 : j - i;
            //更新hm值
            hm.put(s.charAt(j),j);
            res = Math.max(res,tmp);
        }
        return res;
    }
}

4.3  复杂度分析

• 时间复杂度为，其中外循环遍历字符串N次，内循环寻找索引 i 最坏情况下 j 次，因此时间复杂度为；
• 空间复杂度为O(1)，几个变量使用常数大小的额外空间；

五、双指针+哈希表(滑动窗口)

5.1  思路分析

1. 这一次仍然使用哈希表记录距离字符s[j]最近的那个索引 i；
2. 第一种方法是考虑了索引 i 位置的所有情况，第二种方法通过线性遍历寻找索引 i ，而这种方法通过双指针，将 i 视为左指针，通过更新使得在[i+1,j]区间内无重复字符；
3. 那么如何更新左指针呢？一开始初始化 i < 0(比如到第一个字符时，其 i 不存在，故用负数表示)，当遍历到字符s[j]时， 取出哈希表中距离字符s[j]最近的那个索引，将该索引与左指针 i 取最大值；
4. 因为[i+1,j]区间内没有重复元素，故每轮更新j - i，最后返回最大值；

5.2  代码实现

class Solution {
    public int lengthOfLongestSubstring(String s) {
        Map<Character,Integer> hm = new HashMap<>();
        int res = 0;
        int i = -1;
        for(int j = 0; j < s.length(); j++) {
            if(hm.containsKey(s.charAt(j))) {
                i = Math.max(i,hm.get(s.charAt(j)));
            }
            hm.put(s.charAt(j),j);
            res = Math.max(res,j-i);
        }
        return res;
    }
}

5.3  复杂度分析

•  时间复杂度为O(N)，其中N为字符串长度；
• 空间复杂度为O(1)，哈希表最多存储128位，外加几个变量占用常数级别的额外空间；

六、学习地址

作者：Krahets

链接：https://leetcode-cn.com/problems/zui-chang-bu-han-zhong-fu-zi-fu-de-zi-zi-fu-chuan-lcof/solution/mian-shi-ti-48-zui-chang-bu-han-zhong-fu-zi-fu-d-9/