【剑指Offer】最长不含重复字符的子字符串（动态规划+哈希表更新每个字符最近一次出现的下标位置）

题目

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

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

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

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

思路

动态规划+哈希表

• 动态规划：设dp[i]表示以i为结尾的不含重复字符的子字符串长度。
• 那么初始值dp[0]=1，最终的目的是求最长即max(dp[0], … , dp[s.length()-1])。
• 状态转移方程: 判断最近s[j]同字符的出现位置是否被dp[j-1]包含
  （1）如果不存在或者不包含那就直接累加：dp[j] = dp[j-1]+1（即对于s[j]左边的字符，如果有和s[j]相同的字符，设最近的一个的下标为i,那么这个条件相当于是j-i>dp[j-1]。不存在的话i=-1 ）
  （2）否则如果有重复的，那dp[j]=j-i
• 由此我们需要记录每个字符最近一次出现的下标位置，可用哈希表

时间复杂度O(N)，空间复杂度O(N)：哈希表和dp数组。

class Solution {
     
public:
    int lengthOfLongestSubstring(string s) {
     
        /*
        动态规划：设dp[i]表示以i为结尾的不含重复字符的子字符串长度。
        那么初始值dp[0]=1，最终的目的是求最长即max(dp[0], ... , dp[s.length()-1])。
        状态转移方程:
        （1）dp[j] = dp[j-1]+1（对于s[j]左边的字符，如果有和s[j]相同的字符，设最近的一个的下标为i,那么这个条件相当于是j-i>dp[j-1]。不存在的话i=-1 ）
        （2）否则如果有重复的，那dp[j]=j-i
        由此我们需要记录每个字符最近一次出现的下标位置，可用哈希表
        */
        int size=s.length();
        if(size<=1){
     
            return size;
        }
        int anws = 0;
        vector<int> dp(size);
        unordered_map<char,int> unmap; //记录每个字符最近一次出现的下标位置
        //初始
        dp[0]=1;
        unmap[s[0]] = 0;
        //开始遍历
        for(int i=1;i<size;i++){
     
            //从未出现：直接累加，并记录位置
            if( unmap.find(s[i]) == unmap.end() ){
     
                dp[i] = dp[i-1] + 1;
            }else{
     
                //判断最近出现的位置是否被dp[i-1]包含
                int pos = unmap[s[i]];
                //不包含：直接累加，更新位置
                if( (i-pos) > dp[i-1] ){
      
                    dp[i] = dp[i-1] + 1;
                }else{
     //包含：那就从不包含的位置开始算起，并更新位置
                    dp[i] = i - pos;
                }
            }
            //记录或更新位置
            unmap[s[i]] = i;
            //更新最长值
            if( anws < dp[i] )
                anws = dp[i];
        }
        return anws;
    }
};

节省空间

因为每次dp只用到上一次的值，所以我们不用数组存所有dp，只保存上一次的即可，节省空间。cur表示dp[i]，pre表示dp[i-1]

时间复杂度O(N)，空间复杂度O(N)：哈希表。

class Solution {
     
public:
    int lengthOfLongestSubstring(string s) {
     
        /*
        动态规划：设dp[i]表示以i为结尾的不含重复字符的子字符串长度。
        那么初始值dp[0]=1，最终的目的是求最长即max(dp[0], ... , dp[s.length()-1])。
        状态转移方程:
        （1）dp[j] = dp[j-1]+1（对于s[j]左边的字符，如果有和s[j]相同的字符，设最近的一个的下标为i,那么这个条件相当于是j-i>dp[j-1]。不存在的话i=-1 ）
        （2）否则如果有重复的，那dp[j]=j-i
        由此我们需要记录每个字符最近一次出现的下标位置，可用哈希表
        因为每次dp只用到上一次的值，所以我们不用数组存所有dp，只保存上一次的即可，节省空间
        */
        int size=s.length();
        if(size<=1){
     
            return size;
        }
        int anws = 0;
        unordered_map<char,int> unmap; //记录每个字符最近一次出现的下标位置
        //初始
        int pre,cur;
        pre=1;
        unmap[s[0]] = 0;
        //开始遍历
        for(int i=1;i<size;i++){
     
            //从未出现：直接累加，并记录位置
            if( unmap.find(s[i]) == unmap.end() ){
     
                cur = pre + 1;
            }else{
     
                //判断最近出现的位置是否被dp[i-1]包含
                int pos = unmap[s[i]];
                //不包含：直接累加，更新位置
                if( (i-pos) > pre ){
      
                    cur = pre + 1;
                }else{
     //包含：那就从不包含的位置开始算起，并更新位置
                    cur = i - pos;
                }
            }
            //记录或更新位置
            unmap[s[i]] = i;
            //更新最长值
            if( anws < cur )
                anws = cur;
            //更新pre
            pre = cur;
        }
        return anws;
    }
};