2021-5-17 剑指 Offer 48. 最长不含重复字符的子字符串(动态规划，滑动窗口)

注：

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

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

提示：
s.length <= 40000

题解：

方法一 动态规划

解题思路：
长度为 N 的字符串共有(1+N)N/2个子字符串（复杂度为 O(N^2)），判断长度为 N 的字符串是否有重复字符的复杂度为 O(N) ，因此本题使用暴力法解决的复杂度为 O(N^3)。考虑使用动态规划降低时间复杂度。

动态规划解析：
状态定义： 设动态规划列表 dp ，dp[j] 代表以字符 s[j] 为结尾的 “最长不重复子字符串” 的长度。

转移方程： 固定右边界 j ，设字符 s[j] 左边距离最近的相同字符为 s[i] ，即 s[i] = s[j]。

当 s[j] 左边无相同字符时，则dp[j]=dp[j−1]+1 ；

当 dp[j - 1] < j - i ，说明字符 s[i] 在子字符串 dp[j−1] 区间之外 ，则 dp[j] = dp[j - 1] + 1；

当 dp[j−1]≥j−i ，说明字符 s[i] 在子字符串 dp[j−1] 区间之中 ，则 dp[j] 的左边界由 s[i] 决定，即 dp[j] = j - i；
​
返回值： max(dp) ，即全局的 “最长不重复子字符串” 的长度。

观察转移方程，可知问题为：每轮遍历字符 s[j]s[j] 时，如何计算索引 i ？

以下介绍 哈希表 ， 线性遍历 两种方法。

1.动态规划+哈希表

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if(s==""){
            return 0;
        }
        //每个元素最后出现的位置
        map<char,int> dir;
        vector<int> dp(s.size());
        dp[0]=1;
        dir[s[0]]=0;
        for(int j=1;j<s.size();j++){
            if(dir.count(s[j])==1){
                //获取与s[j]相同的元素的索引
                int index=dir[s[j]];
                //更新s[j]最后出现的位置
                dir[s[j]]=j;
                if(dp[j-1]>=j-index){
                    dp[j]=j-index;
                }
                else{
                    dp[j]=dp[j-1]+1;
                }
            }
            else{
                //更新s[j]最后出现的位置
                dir[s[j]]=j;
                dp[j]=dp[j-1]+1;
            }
        }
        return *max_element(dp.begin(), dp.end());
    }
};

复杂度分析：
时间复杂度 O(N) ： 其中 N 为字符串长度，动态规划需遍历计算 dp 列表。
空间复杂度 O(N) ： dp数组的大小为N，哈希表大小最大为N。

空间复杂度优化
由于返回值是取 dp 列表最大值，因此可借助变量 tmp 存储 dp[j] ，变量 res 每轮更新最大值即可。
此优化可节省 dp 列表使用的 O(N) 大小的额外空间。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if(s==""){
            return 0;
        }
        //每个元素最后出现的位置
        map<char,int> dir;
        dir[s[0]]=0;
        //子串长度初始为1
        int temp=1;
        int result=temp;
        for(int j=1;j<s.size();j++){
            if(dir.count(s[j])==1){
                //获取与s[j]相同的元素的索引
                int index=dir[s[j]];
                //更新s[j]最后出现的位置
                dir[s[j]]=j;
                if(temp>=j-index){
                   temp=j-index;
                }
                else{
                    temp=temp+1;
                }
            }
            else{
                //更新s[j]最后出现的位置
                dir[s[j]]=j;
                temp=temp+1;
            }
            result=max(result,temp);
        }
        return result;
    }
};

复杂度分析：
时间复杂度 O(N) ： 其中 N 为字符串长度，动态规划需遍历计算 dpdp 列表。
空间复杂度 O(1) ： 字符的 ASCII 码范围为 0 ~ 127 ，哈希表dic 最多使用 O(128) = O(1) 大小的额外空间。

2.动态规划+线性遍历

遍历到 s[j] 时，初始化索引 i = j - 1 ，向左遍历搜索第一个满足 s[i] = s[j]的字符。

复杂度分析：
时间复杂度 O(N^2)： 其中 N 为字符串长度，动态规划需遍历计算 dp 列表，占用 O(N) ；每轮计算 dp[j] 时搜索 i 需要遍历 j 个字符，占用 O(N) 。
空间复杂度 O(1) ： 几个变量使用常数大小的额外空间。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if(s==""){
            return 0;
        }
        //子串长度初始为1
        int temp=1;
        int result=temp;
        for(int j=1;j<s.size();j++){
            int i=j-1;
            while(i>=0&&s[i]!=s[j]){
                i--;
            }
            if(i<0){
                temp=temp+1;
            }
            else{
                if(temp>=j-i){
                    temp=j-i;
                }
                else{
                    temp=temp+1;
                }
            }
            result=max(result,temp);
        }
        return result;
    }
};

方法二 滑动窗口
1.滑动窗口+双指针

题目中要求答案必须是 子串 的长度，意味着子串内的字符在原字符串中一定是连续的。因此我们可以将答案看作原字符串的一个滑动窗口，并维护窗口内不能有重复字符，同时更新窗口的最大值。

算法
①初始化头尾指针 head，tail；
②tail 指针右移，判断 tail 指向的元素是否在 [head:tail] 的窗口内；
③如果窗口中没有该元素，则将该元素加入窗口，同时更新窗口长度最大值，tail 指针继续右移；
④如果窗口中存在该元素，则将 head 指针右移，直到窗口中不包含该元素。
⑤返回窗口长度的最大值。

复杂度分析
时间复杂度O(n^2)
空间复杂度O(1): 使用了 head，tail，res。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if(s==""){
            return 0;
        }
        int len=1;
        int result=len;
        int head=0;
        int tail=0;
        while(tail<=s.size()-1){
            //index为[head,tail]中与tail值相同的元素的最后出现位置；
            int index=-1;
            //查找tail是否在[head,tail]中出现过
            for(int i=head;i<tail;i++){
                if(s[i]==s[tail]){
                    index=i;
                }
            }
            //若出现过，则重新设定head
            if(index!=-1){
                head=index+1;
            }
            //若未出现过，则不需要重新设定head
            len=tail-head+1;
            result=max(len,result);
            tail+=1;
        }
        return result;
    }
};

2.滑动窗口+哈希表
我们可以使用哈希表记录每个字符的下一个索引，然后尽量向右移动尾指针来拓展窗口，并更新窗口的最大长度。如果尾指针指向的元素重复，则将头指针直接移动到窗口中重复元素的右侧。

复杂度分析
时间复杂度O(n)
空间复杂度O(n)：使用了map，大小为n。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if(s==""){
            return 0;
        }
        int len=1;
        int result=len;
        int head=0;
        int tail=0;
        map<char,int> dir;
        while(tail<=s.size()-1){
            //若尾部指针存在于map，对头指针进行重新计算
            if(dir.count(s[tail])==1){
                head=max(head,dir[s[tail]]+1);
            }
            dir[s[tail]]=tail;
            len=tail-head+1;
            result=max(result,len);
            tail+=1;
        }
        return result;
    }
};