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

思路

方法一：暴力法

对于字符串s，用f[i]表示以s[i]开头的无重复字符的字符串最大长度，

逐一求出f[0], f[1], ... ,f[s.length()-1] ，最后返回这些值中的最大值即可。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if(s.empty())
            return 0;
        //f[i]表示以字符s[i]开头的最长无重复字符串
        vector<int> f(s.size(), 0);
        unordered_map<char, bool> vis; 

        for(int i = 0; i < s.length(); ++i) {
            vis[s[i]] = true;
            f[i] = 1;
            for(int j = i+1; j < s.length(); ++j) {
                if(!vis[s[j]]) {
                    vis[s[j]] = true;
                    f[i]++;
                } else {
                    for(int k = i; k <= j; ++k) {
                        if(vis[s[k]])
                            vis[s[k]] = false;
                    }
                    break;
                }
            }
        }

        int maxlen = -1;
        for(int i = 0; i < f.size(); ++i) {
            if(f[i] > maxlen)  
                maxlen = f[i];
        }

        return maxlen;
    }
};

复杂度分析

时间复杂度：O(n²)

空间复杂度：O(n)

空间优化：由于最后只需要求f[]数组中的最大值，所以可以只用一个表示最大值的变量来代替f[]数组，这样可以减少n个大小的空间，但空间复杂度还是O(n)，因为unordered_map仍然需要O(n)的空间。

以下方法都参考题解：面试题48. 最长不含重复字符的子字符串（动态规划 / 双指针 + 哈希表，清晰图解）

方法二：动态规划

方法2.1 动态规划 + 哈希表

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if(s.empty())
            return 0;
        unordered_map<char, int> dic;
        vector<int> dp(s.size());
        dp[0] = 1;
        dic[s[0]] = 0;

        int i = -1;
        for(int j = 1; j < s.size(); ++j) {
            //获取索引位置i
            if(dic.count(s[j]) == 1)
                i = dic[s[j]];
            else
                i = -1; 
            
            dic[s[j]] = j;  //更新哈希表

            if(dp[j-1] < j-i) {
                dp[j] = dp[j-1] + 1;
            } else {
                dp[j] = j-i;
            }
        }

        //返回dp数组中的最大值
        int res = dp[0];
        for(int j = 1; j < dp.size(); ++j) {
            if(dp[j] > res)
                res = dp[j];
        }

        return res;
    }
};

 

 空间优化后的代码如下：

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        unordered_map<char, int> dic;
        int res = 0;

        int i = -1;
        int tmp = 0;
        for(int j = 0; j < s.size(); ++j) {
            if(dic.count(s[j]) == 1)
                i = dic[s[j]];
            else
                i = -1; 
            
            dic[s[j]] = j;
            
            if(tmp < j-i) {
                tmp = tmp + 1;
            } else {
                tmp = j-i;
            }

            res = max(res, tmp);
        }

        return res;
    }
};

 

方法2.2 动态规划 + 线性遍历

 

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int res = 0;
        int tmp = 0;

        for(int j = 0; j < s.size(); ++j) {
            int i = j-1;
            while(i >= 0 && s[i] != s[j]) {
                --i;    //线性查找
            }

            if(tmp < j-i) {
                tmp = tmp + 1;
            } else {
                tmp = j-i;
            }

            res = max(res, tmp);
        }

        return res;
    }
};

方法三：双指针 + 哈希表 (滑动窗口)

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        unordered_map<char, int> dic;
        int i = -1, res = 0;
        for(int j = 0; j < s.length(); j++) {
            if(dic.count(s[j]) == 1)
                i = max(i, dic[s[j]]);  // 更新左指针 i
            dic[s[j]] = j;    // 更新哈希表记录
            res = max(res, j - i); // 更新结果
        }

        return res;
    }
};