关于滑动窗口解决子串问题

最新推荐文章于 2024-09-19 23:46:48 发布

进击ing小白

最新推荐文章于 2024-09-19 23:46:48 发布

阅读量482

点赞数

分类专栏： leetcode字符串

本文链接：https://blog.csdn.net/WSTONECH/article/details/90381061

版权

leetcode字符串专栏收录该内容

0 篇文章 0 订阅

订阅专栏

滑窗思想：

在解决字符串子串问题时，可以采用滑窗的思想；

1，在字符串S中使用双指针中左右指针技巧，初始化left = right = 0,把索引[left,right]成为一个窗口

2，不断增加right指针扩大窗口[left,right],直到窗口中字符串符合要求

3，停止增加right,同时不断增加left缩小窗口，直到窗口中字符串不再符合要求，同时每增加一次left更新一轮结果

4，重复2-4直到right到达字符串S的劲头。

滑窗编程范式：

// 滑窗思想解决字符串子串问题

int left = 0, right = 0;

while (right < s.size()) {
	window.add(s[right]);//滑动右边界
	right++;

	while (valid) {		//满足条件，滑动左边界，
		window.remove(s[left]);
		left++;
}
}

力扣76：最小覆盖子串

代码实现：

class Solution {
public:
    string minWindow(string s, string t) {
        int start = 0,minLen = INT_MAX;
        int left = 0,right = 0;
        unordered_map<char,int>window;//统计窗内需要匹配的字母和频次
        unordered_map<char,int>needs;//统计需要匹配的字母和频次
        for(auto c:t)
            needs[c]++;
        int matchs = 0;//统计字母匹配结果，如window有5个g，needs有5个g则g匹配
        while(right<s.size())
        {
            char c1 = s[right];
            if(needs.count(c1))
            {
                window[c1]++;
                if(window[c1] == needs[c1])
                    matchs++;
            }
            right++;
            
            while(matchs == needs.size())
            {
                if(right - left<minLen)
                {
                    minLen = right - left;
                    start = left;
                }
                char c2 = s[left];
                if(needs.count(c2)){
                    window[c2]--;
                    if(window[c2] < needs[c2])
                        matchs--;
                }
                left++;
            }
            
        }
        return minLen == INT_MAX? "":s.substr(start,minLen);
    }
};

测试结果：

力扣438：找字符串中所有异位词

代码实现：

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
	vector<int>result;
	int left = 0, right = 0;
	int match = 0;
	unordered_map<char, int>needs;//记录需要异位的字符和频次
	unordered_map<char, int>window;//记录窗里面需要异位的字符及频次
	for (auto c : p)
		needs[c]++;

	while (right < s.size())
	{
		char c1 = s[right];
		if (needs.count(c1))//判断是不是需要异位的字母，进行窗记录
		{
			window[c1]++;
			if (window[c1] == needs[c1])
			{
				match++;
			}
		}
		right++;
		while (match == needs.size())
		{
			if (right - left == p.size())//字母匹配后判断长度匹配，否则可能窗内有多余非异位字母
			{
				result.push_back(left);
			}
			char c2 = s[left];
			if (needs.count(c2))//判断移除窗外的左边界是否异位词，更新window
			{
				window[c2]--;
				if (window[c2]<needs[c2])
					match--;
			}
			left++;
		}
	}
	return result;
}
};

测试结果：

力扣3：无重复最长子串：

代码实现：

class Solution {
public:
   int lengthOfLongestSubstring(string s) {
	unordered_map<char, int>window;
	int left = 0, right = 0;
	int res = 0;
	while (right<s.size())
	{
		char c1 = s[right];
		window[c1]++;
		right++;
		while (window[c1]>1)//有边界出现重复，移动左边界直到不重复为止；
		{
			char c2 = s[left];
			window[c2]--;
			left++;
		}
		res = max(res, right - left);
	}
	return res;
}
};

测试结果：