【LeetCode】【哈希表，动态规划，队列】剑指 Offer 48. 最长不含重复字符的子字符串 思路解析和代码

剑指 Offer 48. 最长不含重复字符的子字符串

题目链接

个人思路

思路

暴力+map思路

• 双循环遍历字符串，求出每一位字符的最长不含重复字符的子字符串长度
• 使用map判重
• 每次遍历后要对长度初始化为0，清空map

内存溢出dp(dp+map)

• dp[i][j]表示字符串i~j的最长不含重复字符的子字符串长度为dp[i][j]
• 递推式：若遇到重复元素：dp[i][j] = dp[i][j - 1];若无重复元素：dp[i][j] = dp[i][j - 1] + 1;
• 递推过程中使用map判重，做一些剪枝操作，记录最大长度

这个思路应该是对的，应该是数组40000*40000的数组开销太大

dp

这种动态规划方法不是很容易理解
dp[i]表示第i个字符的最长不含重复字符的子字符串长度为dp[i]
自顶向下分析：

• 求最优解：求最长不含重复字符的子字符串
• 最优子结构：题目中最长不含重复字符的子字符串，可以有子问题中的最长不含重复字符的子字符串得到
• 重叠子问题：每个子问题求解时，都要从边界第一个字符开始计算

自下而上解决问题：

• 边界：dp[0] = 1
• 状态转移：通过map记录当前字符上一次出现的位置i
  • 当前字符未出现过：dp[j] = dp[j - 1] + 1
  • 当前字符出现过：j-i表示重复字符之间的下标距离
    • 当dp[j-1]<j - i:说明重复字符之间的距离更长，说明上一个重复的字符已经超出j-1位置的最长字符串，因此把当前字符加到当前字符串中是合理的，不会出现重复的字符，即dp[j] = dp[j - 1] + 1
    • 当dp[j-1] >= j-i，说明j-1位置的最长字符串更长，说明上一个重复的字符已经在j-1位置的最长字符串中出现，因此不能将当前字符加到当前字符串中，当前位置的最长字符串应该是重复字符之间的下标距离j-i，即dp[j] = j-i

模拟：队列+map

• 使用队列（队列作为一个滑动窗口，存放当前不重复字符串）模拟整个求解过程，过程中使用map进行判重
• 若当前元素不在队列中，则当前元素入队
• 若当前元素在队列中，将与当前元素重复的元素及其前面的所有元素出队
• PS:使用map判断元素是否在队列中，或者用deque按下标进行遍历也可以

个人思路代码

暴力+map

class Solution {
public:
    unordered_map<char, int> mp;
    int ans, temp;
    int lengthOfLongestSubstring(string s) {
        for(int i = 0; i < s.size(); ++i){
            mp[s[i]]++;
            temp++;
            for(int j = i + 1; j < s.size(); ++j){
                mp[s[j]]++;
                if(mp[s[j]] > 1){//出现重复元素
                    break;
                }
                temp++;
            }
            if(temp > ans){
                ans = temp;
            }
            temp = 0;
            mp.clear();
        }
        return ans;
    }
};

内存溢出dp(dp+map)

class Solution {
public:
    int dp[40015][40015];//dp[i][j]表示字符串i~j中最长不含重复字符的子字符串长度为dp[i][j]
    unordered_map<char, int> mp;
    int lengthOfLongestSubstring(string s) {
        int len = s.size();
        int ans = 0;
        if(len == 0){
            return 0;
        }
        if(len == 1){
            return 1;
        }
        for(int i = 0; i < len; ++i){//边界
            dp[i][i] = 1;
        }
        for(int i = 0; i < len; ++i){
            bool isSame = false;
            mp[s[i]]++;
            for(int j = i; j < len; ++j){
                if(j <= i)
                    continue;
                if(isSame == true){
                    break;
                }
                mp[s[j]]++;
                if(mp[s[j]] > 1){//遇到重复元素
                    isSame = true;
                    dp[i][j] = dp[i][j - 1];
                }else{
                    dp[i][j] = dp[i][j - 1] + 1;
                }
                if(dp[i][j] > ans){
                    // cout << ans << endl;
                    ans = dp[i][j];
                }
            }
            mp.clear();
        }
        return ans;
    }
};

dp

temp:暂存dp[j]中的数值。使用temp的原因是当j=0时，dp[j-1]越界，而temp初始值为0，便于表示此时的dp[j-1]

class Solution {
public:
    int dp[40005];
    unordered_map<char, int> mp;
    int lengthOfLongestSubstring(string s) {
        int ans = 0;
        int temp = 0;
        if(s.size() == 0){
            return ans;
        }
        for(int j = 0; j < s.size(); ++j){
            int i = -1;//记录当前字符上一次出现的位置
            if(mp.count(s[j]) != 0){//不是新字符
                i = mp[s[j]];
            }
            mp[s[j]] = j;
            if(temp < j - i){
                temp = temp + 1;
            }else{
                temp = j - i;
            }
            dp[j] = temp;
            ans = max(ans , dp[j]);
        }
        return ans;
    }
};

队列+map

class Solution {
public:
    deque<char> q;
    unordered_map<char, int>mp;
    int ans;
    int lengthOfLongestSubstring(string s) {
        if(s.size() == 0){
            return 0;
        }
        for(int i = 0; i < s.size(); ++i){
            char cur = s[i];
            if(!q.empty()){
                if(mp[cur] >= 1){//判重，说明有重复元素
                    while(1){//将重复元素及重复元素之前的所有元素出队
                        char head = q.front();
                        q.pop_front();
                        mp[head]--;
                        if(head == cur){
                            break;
                        }
                    }
                }
            }
            q.push_back(cur);
            mp[cur]++;
            int temp = q.size();
            ans = max(ans, temp);
        }
        return ans;
    }
};