LC3. 无重复字符的最长子串---滑动窗口不定长

题目描述

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: s = "abcabcbb"

输出: 3

解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

输入: s = "bbbbb"

输出: 1

解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

思路

题目解析

很经典的滑动窗口的题目。

具体操作如下：

1、定义需要维护的变量，对于此题来说，要求是最大长度，同时又涉及去重，因此需要一个哈希表。

2、定义窗口的首尾端 (start, end)， 然后滑动窗口。

3、窗口的右端位置从 0 开始，可以一直移动到尾部。

4、如果哈希表中存储了即将加入滑动窗口的元素，那么需要不断的把窗口左边的元素移除窗口。

代码

#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <unordered_set>

using namespace std;

class Solution {
public:
    int lengthOfLongestSubstring(string s) {

        // 滑动窗口模板化解题，五步走策略

        // 【1、定义需要维护的变量】

        // 对于此题来说，要求是最大长度
        int maxLen = 0;

        // 同时又涉及去重，因此需要一个哈希表
        unordered_set<char> hash;

        // 【2、定义窗口的首尾端 (start, end)， 然后滑动窗口】

        // 窗口的左端位置从 0 开始
        int start = 0;

        // 窗口的右端位置从 0 开始，可以一直移动到尾部
        for (int end = 0; end < s.length(); end++) {

            // 【3、更新需要维护的变量, 有的变量需要一个 if 语句来维护 (比如最大最小长度)】

            // 【4、如果题目的窗口长度可变: 这个时候一般涉及到窗口是否合法的问题】
            //  如果当前窗口不合法时, 用一个 while 去不断移动窗口左指针, 从而剔除非法元素直到窗口再次合法

            // 如果哈希表中存储了即将加入滑动窗口的元素
            while (hash.count(s[end])) {

                // 那么需要不断的把窗口左边的元素移除窗口

                // 把 s.charAt(start) 移除记录
                hash.erase(s[start]);

                // 窗口左端向右移动
                start++;
            }

            // 此时，滑动窗口可以接纳 s.charAt(end)
            hash.insert(s[end]);

            // 维护变量 maxLen
            maxLen = max(maxLen, end - start + 1);

        }
        
        // 【5、返回所需要的答案】
        return maxLen;

    }
};

class Solution1 {
public:
    int lengthOfLongestSubstring(string s) {
        // 哈希集合，记录每个字符是否出现过
        unordered_set<char> occ;
        int n = s.size();
        // 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
        int rk = -1, ans = 0;
        // 枚举左指针的位置，初始值隐性地表示为 -1
        for (int i = 0; i < n; ++i) {
            if (i != 0) {
                // 左指针向右移动一格，移除一个字符
                occ.erase(s[i - 1]);
            }
            while (rk + 1 < n && !occ.count(s[rk + 1])) {
                // 不断地移动右指针
                occ.insert(s[rk + 1]);
                ++rk;
            }
            // 第 i 到 rk 个字符是一个极长的无重复字符子串
            ans = max(ans, rk - i + 1);
            
        }
        return ans;
    }
};

class Solution2 {//输出无重复最长子串本身，并输出该最长子串长度
private:
    static int maxlen;
    static string ans;

public:
    
    void lengthOfLongestSubstring(string s);
    void show();


};

int Solution2::maxlen = 1;
string Solution2::ans = "";

void Solution2::lengthOfLongestSubstring(string s) {
    // 哈希集合，记录每个字符是否出现过
    unordered_set<char> occ;
    int n = s.size();
    // 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
    int rk = -1;
    //string ans;
    int start = 0;
    // 枚举左指针的位置，初始值隐性地表示为 -1
    for (int i = 0; i < n; ++i) {
        if (i != 0) {
            // 左指针向右移动一格，移除一个字符
            occ.erase(s[i - 1]);
        }
        while (rk + 1 < n && !occ.count(s[rk + 1])) {
            // 不断地移动右指针
            occ.insert(s[rk + 1]);
            ++rk;
        }
        // 第 i 到 rk 个字符是一个极长的无重复字符子串
        if (rk - i + 1 > maxlen) {
            maxlen = rk - i + 1;
            start = i;
        }

    }
    ans = s.substr(start, maxlen);
}

void Solution2::show() {
    cout << "最长子串：" << ans << "长度是：" << maxlen << endl;
}

int main() {
    string input;
    getline(cin, input);//"abcabcbb"

    Solution2 a;
    a.lengthOfLongestSubstring(input);    
    a.show();
}

 

复杂度分析

• 时间复杂度：O(N)，其中 N是字符串的长度。左指针和右指针分别会遍历整个字符串一次。

• 空间复杂度：O(∣Σ∣)，其中 Σ 表示字符集（即字符串中可以出现的字符），∣Σ∣ 表示字符集的大小。