[C++] 在连续统上的重复性质：滑动窗口

最新推荐文章于 2023-05-23 23:27:44 发布

原创最新推荐文章于 2023-05-23 23:27:44 发布 · 95 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #leetcode #动态规划

博客讲述了如何使用滑动窗口算法优化解决给定字符串中无重复字符的最长子串问题。作者首先介绍了暴力解法存在的问题，然后逐步改进代码，通过两个指针来跟踪子串的起始和结束位置，避免重复检查字符。虽然经过多次修改，但代码仍然存在错误。博客旨在探讨字符串处理和滑动窗口算法的应用。

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

示例 1:

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

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

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

输入: s = “”
输出: 0

提示：

0 <= s.length <= 5 * 104
s 由英文字母、数字、符号和空格组成

一开始我的代码


class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int maxLength = 0;
        function <int(string::iterator)> getLength = [&](string::iterator iter_curr)
        {
            set<int> charCache;
            for(; iter_curr < s.end(); ++iter_curr)
            {
                if(charCache.find(*iter_curr) == charCache.end())
                    charCache.insert(*iter_curr);
                else
                    return charCache.size();
            }
            return charCache.size();
        };
        for(auto iter = s.begin(); iter < s.end(); ++iter)
        {
            int lengthCache = getLength(iter);
            if(maxLength < lengthCache)
                maxLength = lengthCache;
        }
        return maxLength;
    }
};

暴力解法，太费时间了
看了题解，可以使用滑动窗口
滑动窗口是需要长度变化有一定规律的
最长子串刚好有一个特点是，从一个位置开始的子串和从另一个位置开始的子串之间是有互相重叠的部分的，这个重叠的部分就是，最耗时间的，因为如果每一次选定子串头开始找最长子串都要从 0 开始找，那么就相当于把这个重复的部分找了很多次。
那么现在就是知道了，我不想找重复的部分，但是我怎么实现呢
就是，用两个指针，记录下子串结束的位置，每一次移动左指针的时候，右指针不动，这个不动代表着，默认现在左右指针之间的部分就是符合要求的，即字符不重复的，然后左指针这一次移动好了之后，我就继续尝试移动右指针，直到右指针不能动了为止，才让左指针再继续移动，然后重复下一轮的右指针移动检查；什么时候右指针不能动呢，就是发现要移动到的位置与已有的字串中重复了

我一开始还这样写


class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        
        string::iterator iterL;
        string::iterator iterR;
        set<int> charCache;
        int maxLength = 0;
        int lengthCache = 0;

        for(iterL = s.begin(), iterR = s.begin(); iterL < s.end(); )
        {
            // 初始化
            if(iterR == s.begin())
                charCache.insert(*iterR);
            
            // 右指针移动
            while(true)
            {
                ++iterR;
                if(iterR >= s.end())
                    break;
                if(charCache.find(*iterR) == charCache.end())
                    charCache.insert(*iterR);
                else
                    break;
            }

            // 记录长度，取最大值
            lengthCache = charCache.size();
            maxLength = max(maxLength,lengthCache);
            
            charCache.erase(*iterL);
            ++iterL;
        }
        return maxLength;
    }
};

错就错在 iterR 指向的元素如果在检查的时候没有加入 set 的话，在下一次 iterL 移动之后，再次检查 iterR 时，就会跳过这个指向的元素，直接检查下一个
于是我改成了


class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        
        string::iterator iterL;
        string::iterator iterR;
        set<int> charCache;
        int maxLength = 0;
        int lengthCache = 0;

        for(iterL = s.begin(), iterR = s.begin(); iterL < s.end(); )
        {
            // 初始化
            if(iterR == s.begin())
                charCache.insert(*iterR);
            
            // 右指针移动
            while(true)
            {
                ++iterR;
                if(iterR >= s.end())
                    break;
                if(charCache.find(*iterR) == charCache.end())
                    charCache.insert(*iterR);
                else
                {
                    --iterR;
                    break;
                }
            }

            // 记录长度，取最大值
            lengthCache = charCache.size();
            maxLength = max(maxLength,lengthCache);
            
            charCache.erase(*iterL);
            ++iterL;
        }
        return maxLength;
    }
};

但是还是有错
再改了一下，因为感觉在循环里面先递增右指针不太好


class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        
        string::iterator iterL;
        string::iterator iterR;
        set<int> charCache;
        int maxLength = 0;
        int lengthCache = 0;

        for(iterL = s.begin(), iterR = s.begin(); iterL < s.end(); )
        {
            // 初始化
            if(iterR == s.begin())
                charCache.insert(*iterR);
            
            // 右指针移动
            while(true)
            {
                if(iterR + 1 >= s.end())
                    break;
                if(charCache.find(*(iterR + 1)) == charCache.end())
                {
                    ++iterR;
                    charCache.insert(*iterR);
                }
                else
                {
                    break;
                }
            }

            // 记录长度，取最大值
            lengthCache = charCache.size();
            maxLength = max(maxLength,lengthCache);
            
            charCache.erase(*iterL);
            ++iterL;
            if(int(iterL - iterR) > 0)
            {
                iterR = iterL;
                charCache.insert(*iterR);
            }
        }
        return maxLength;
    }
};