LeetCode刷题day20

算法打卡第二十天,今天你刷题了吗
😄😄😄😄😄😄😄😄😄😄
😃😃😃😃😃😃😃😃😃😃
💓💓💓大家一起来刷题!💓💓💓
😍😍😍😍😍😍😍😍😍😍
😘😘😘😘😘😘😘😘😘😘

今日刷题重点----滑动窗口法

209. 长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

示例 1：

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2

解释：子数组 [4,3] 是该条件下的长度最小的子数组。

示例 2：

输入：target = 4, nums = [1,4,4]
输出：1

示例 3：

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

方法一:暴力法

使用两个for循环,依次判断寻找最小的子序列

参考代码1

//方法一:暴力解法
int minSubArrayLen(int target, vector<int>& nums) {
	int result = INT_MAX;
	int str_len = 0;//子序列长度
	int sum = 0;//子序列的和
	for(int i = 0; i < nums.size(); i++) {
		sum = 0;
		for(int j = i; j < nums.size(); j++) {
			sum+=nums[j];
			if(sum>=target) {
				str_len = j-i+1;
				result = result>=str_len?str_len :result ;
				break;//找到了则一定要break一下.因为需要的是最小长度.
			}

		}
	}
	result = result==INT_MAX ? 0 : result;//如果没有找到, 则result赋值为0
	return result;
}

方法二:滑动窗口法

所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。
算法步骤:

1. 使用两个变量i,j分别表示窗口的两个边界.
2. 当窗口内的值< target时,右边界j进行后移,直至>=target.此时就是以i为左边界的窗口,且满足条件—是最小的子序列.
3. 然后i继续后移,寻找其他最小的窗口,对比判断选择更加符合题意的.

这里还是以题目中的示例来举例，s=7， 数组是 2，3，1，2，4，3，来看一下查找的过程：

参考代码2

//滑动窗口法 
int minSubArrayLen(int target, vector<int>& nums) {
	int result = INT_MAX;//结果 
	int subLength = 0;//滑动窗口的长度
	int sum = 0;//子序列的长度. 
	int i = 0;//滑动窗口的起始位置 
	for(int j = 0;j < nums.size();j++){
		sum+=nums[j];//如果不满足条件,则不断增大窗口的右边界. 
		while(sum>=target){
			subLength = j-i+1;
			result = result>=subLength ? subLength : result;
			sum -=nums[i++];//如果满足,则窗口右移动,即起始位置后移. 
		}
	} 
	result = result==INT_MAX ? 0 : result;//如果没有找到, 则result赋值为0
	return result;
}

76. 最小覆盖子串

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 “” 。

注意：

对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
如果 s 中存在这样的子串，我们保证它是唯一的答案。

示例 1：

输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"

示例 2：

输入：s = "a", t = "a"
输出："a"

示例 3:

输入: s = "a", t = "aa"
输出: ""

解释: t 中两个字符 ‘a’ 均应包含在 s 的子串中，
因此没有符合条件的子字符串，返回空字符串。

方法一:滑动窗口法

滑动窗口的思想：
用i,j表示滑动窗口的左边界和右边界，通过改变i,j来扩展和收缩滑动窗口，可以想象成一个窗口在字符串上游走，当这个窗口包含的元素满足条件，即包含字符串T的所有元素，记录下这个滑动窗口的长度j-i+1，这些长度中的最小值就是要求的结果。

1.步骤一
不断增加j使滑动窗口增大，直到窗口包含了T的所有元素

2.步骤二
不断增加i使滑动窗口缩小，因为是要求最小字串，所以将不必要的元素排除在外，使长度减小，直到碰到一个必须包含的元素，这个时候不能再扔了，再扔就不满足条件了，记录此时滑动窗口的长度，并保存最小值

3.步骤三
让i再增加一个位置，这个时候滑动窗口肯定不满足条件了，那么继续从步骤一开始执行，寻找新的满足条件的滑动窗口，如此反复，直到j超出了字符串S范围。

面临的问题：
如何判断滑动窗口包含了T的所有元素？??
我们用一个vector<int> need / map来表示当前滑动窗口中需要的各元素的数量，一开始滑动窗口为空，用T中各元素来初始化这个need，当滑动窗口扩展或者收缩的时候，去维护这个need，例如当滑动窗口包含某个元素，我们就让need中这个元素的数量减1，代表所需元素减少了1个；当滑动窗口移除某个元素，就让need中这个元素的数量加1。
记住一点：need始终记录着当前滑动窗口下，我们还需要的元素数量，我们在改变i,j时，需同步维护need。
值得注意的是，只要某个元素包含在滑动窗口中，我们就会在need中存储这个元素的数量，如果某个元素存储的是负数代表这个元素是多余的。比如当need等于{‘A’:-2,‘C’:1}时，表示当前滑动窗口中，我们有2个A是多余的，同时还需要1个C。这么做的目的就是为了步骤二中，排除不必要的元素，数量为负的就是不必要的元素，而数量为0表示刚刚好。
回到问题中来，那么如何判断滑动窗口包含了T的所有元素？
结论就是当need中所有元素的数量都小于等于0时，表示当前滑动窗口不再需要任何元素。

优化
如果每次判断滑动窗口是否包含了T的所有元素，都去遍历need看是否所有元素数量都小于等于0，这个会耗费O(k)的时间复杂度，k代表need长度，最坏情况下，k可能等于len(S)。
其实这个是可以避免的，我们可以维护一个额外的 变量needCnt来记录所需元素的总数量，当我们碰到一个所需元素c，不仅need[c]的数量减少1，同时needCnt也要减少1，这样我们通过needCnt就可以知道是否满足条件，而无需遍历整个数组了。

前面也提到过，need记录了遍历到的所有元素，而只有need[c]>0大于0时，代表c就是所需元素

注意：while(i<j&&need[s[i]]<0){...} 可能理解起来比较复杂~
由于我们刚开始用t对need进行了初始化，所以只要是一些无用字符 或 多余的有用字符，那么气need[s[i]]一定是 < 0的。从而可以进行去重操作！

参考代码

string minWindow(string s, string t) {
	vector<int> need(128,0);//因为是字符,所以都可以找到一个数字进行对应,故可以使用vector类型.同样ordered_map也可以，但是肯定前者效率会更高了，底层是数组~ 
	//ordered_map<char,int> m; 
	int cnt = 0;
	for(char c : t){//对need进行初始化 
		need[c]++;
	}
	cnt = t.size();
	int i ,j,result = INT_MAX,str_len,start=0;//start记录满足条件的窗口的起始位置. 
	for(i = 0,j = 0;j < s.size();j++){
		char c = s[j];
		if(need[c]>0){
			cnt--;//如果当前的字符是t需要的字符并且还没有凑够,则 cnt-- 
		}
		need[c]--;//将右边的字符加入窗口
		if(cnt==0){//窗口已经包含所需要的全部字符 
			while(i<j&&need[s[i]]<0){//排除不必要的字符 
				need[s[i++]]++;
			} 
			str_len = j-i+1;
			if(str_len<result){//更新result和start 
				result = str_len;
				start = i;
			}
			need[s[i++]]++; //左边界进行右移动,寻找下一个窗口..
			cnt++;//需要的目标字符进行增加,因为之前那个是最小的.
		} 
	}
	return result==INT_MAX>"":s.substr(start,result); 
}

附：unordered_map实现

//采用滑动窗口法来解决 
string minWindow(string s, string t) {
	//这里也可以使用vector<int,int> 
	unordered_map<char,int> window;
	int i = 0;
	int str_len = INT_MAX;
	int start  = 0;
	int cnt = t.size();
	// 特殊值的处理 
	if(s.size() < t.size()) {
		return "";
	}
	// window的初始化
	for(char ch : t) {
		window[ch]++;
	}
	//使用滑动窗口法寻找符合的字符串 
	for(int j = 0;j < s.size(); j++){
		if(window[s[j]] > 0) {//判断是否是所需要的字符 
			cnt--;
		}
		window[s[j]]--;//将元素加入窗口
		if(cnt == 0) {//说明窗口已经包含t中所有字符 
			//移除没用的字符 
			while(i <= j && window[s[i]] < 0) {
				window[s[i]]++;
				i++;
			}
			//更新str_len 
			if(j-i+1 < str_len){
				str_len = j-i+1;
				start = i;
			}
			// 开始尝试寻找下一个窗口
			window[s[i]]++;
			i++;
			cnt++; 
		}
	}
	return str_len == INT_MAX ? "" : s.substr(start,str_len);
}

904. 水果成篮

由于本题翻译不准确,我们直接看下英文题目,英文直译如下:
您正在参观一个农场，该农场有一排从左到右排列的果树。
树由整数数组fruits表示，其中水果[i]是第i棵树产生的水果类型。
你想收集尽可能多的水果。但是，所有者有一些严格的规则，您必须遵守：

• 你只有两个篮子，每个篮子只能装一种水果。每篮水果的数量没有限制。
• 从您选择的任何一棵树开始，您必须在向右移动时从每棵树（包括起始树）中恰好摘下一个水果,摘下的水果必须放在你的一个篮子里。 一旦你到了一棵树上，树上的果实没法放入你的篮子（两个篮子已经满了），你必须停下来。

给定整数数组水果，返回可以拾取的最大水果数。

本题，其实就是 选只有两个元素的最长连续子序列，比如1，2，3，2，2最长就是2，3，2，2（只包括2或者3，而且是最长的）。

示例 1：

输入：[1,2,1]
输出：3

解释：我们可以收集 [1,2,1]。

示例 2：

输入：[0,1,2,2]
输出：3

解释：我们可以收集 [1,2,2]
如果我们从第一棵树开始，我们将只能收集到 [0, 1]。

示例 3：

输入：[1,2,3,2,2]
输出：4

解释：我们可以收集 [2,3,2,2]
如果我们从第一棵树开始，我们将只能收集到 [1, 2]。

示例 4：

输入：[3,3,3,1,2,1,1,2,3,3,4]
输出：5

解释：我们可以收集 [1,2,1,1,2]
如果我们从第一棵树或第八棵树开始，我们将只能收集到 4 棵水果树。

思路分析

• 使用i,j分别指向窗口的左右两端.

• 窗口的右边界开始后移直到窗口内元素的个数大于2,

• 然后左窗口进行右移动,直到窗口内只有两种元素.

• 然后更新最大的水果树.最终进行返回.

参考代码

//滑动窗口法 
int totalFruit(vector<int>& fruits) {
	unordered_map<int,int> window;
	int k = 2;
	int result = 0;
	int i = 0;//窗口左边界 
	for(int j = 0;j < fruits.size();j++){ // j:窗口右边界 
		window[fruits[j]]++;//窗口右边界扩大
		while(window.size()>k){//如果当前窗口中元素类型的个数大于k ,则想办法减小到k
			window[fruits[i]]--;
			if(!window[fruits[i]]) {//如果当前元素的个数变为了0,则从窗口中移除该元素. 
				window.erase(fruits[i]);
			}
			i++;//每一次while,窗口右移动 
		} 
		result = max(result,j-i+1); //更新result 
	}
	return result;

}

😜😜😜😜😜 大家卷起来啊,加油!!!冲他妈的! 😜😜😜😜😜