和我一起刷算法吧!今天刷的是数组,滑动窗口!
滑动窗口是特殊的双指针。
滑动窗口
所谓滑动窗口,就是不断的调节子序列的起始位置和终止位置,从而得出我们要想的结果。滑动窗口也可以理解为双指针法的一种!只不过这种解法更像是一个窗口的移动,所以叫做滑动窗口更适合一些。
滑动窗口主要确定如下三点:
- 窗口内是什么?
- 如何移动窗口的起始位置?
- 如何移动窗口的结束位置?
长度最小的子数组
给定一个含有 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循环,然后不断的寻找符合条件的子序列,时间复杂度是O(n^2)。
显然暴力解法绝对不是最优解。
题解:
class Solution {
public int minSubArrayLen(int s, int[] nums) {
int left = 0;
int sum = 0;
int result = Integer.MAX_VALUE;
for (int right = 0; right < nums.length; right++) {
sum = sum + nums[right];
while (sum >= s) {
result = Math.min(result, right - left + 1);
sum = sum - nums[left];
left++;
}
}
return result == Integer.MAX_VALUE ? 0 : result;
}
}
水果成篮
你正在探访一家农场,农场从左到右种植了一排果树。这些树用一个整数数组 fruits
表示,其中 fruits[i]
是第 i
棵树上的水果 种类 。
你想要尽可能多地收集水果。然而,农场的主人设定了一些严格的规矩,你必须按照要求采摘水果:
- 你只有 两个 篮子,并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
- 你可以选择任意一棵树开始采摘,你必须从 每棵 树(包括开始采摘的树)上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次,你将会向右移动到下一棵树,并继续采摘。
- 一旦你走到某棵树前,但水果不符合篮子的水果类型,那么就必须停止采摘。
给你一个整数数组 fruits
,返回你可以收集的水果的 最大 数目。
示例 1:
输入:fruits = [1,2,1]
输出:3
解释:可以采摘全部 3 棵树。
示例 2:
输入:fruits = [0,1,2,2]
输出:3
解释:可以采摘 [1,2,2] 这三棵树。
如果从第一棵树开始采摘,则只能采摘 [0,1] 这两棵树。
示例 3:
输入:fruits = [1,2,3,2,2]
输出:4
解释:可以采摘 [2,3,2,2] 这四棵树。
如果从第一棵树开始采摘,则只能采摘 [1,2] 这两棵树。
示例 4:
输入:fruits = [3,3,3,1,2,1,1,2,3,3,4]
输出:5
解释:可以采摘 [1,2,1,1,2] 这五棵树。
分析:
从示例中可以看出,采摘到最多的水果,是一个连续的范围,可以考虑滑动窗口。
数组的题中,经常会出现HashMap来辅助做题。
本题所用的HashMap中的key表示水果种类,value表示现存数量。
题解:
class Solution {
public int totalFruit(int[] fruits) {
//map的key表示水果种类,value表示现存数量。
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
int left = 0;
int res = 0;
for (int right = 0; right < fruits.length; right++) {
map.put(fruits[right], map.getOrDefault(fruits[right], 0) + 1);
// 通过while循环从哈希表中去掉一种水果
while (map.size() > 2) {
map.put(fruits[left], map.get(fruits[left]) - 1);
if (map.get(fruits[left]) == 0) {
map.remove(fruits[left]);
}
left++;
}
res = Math.max(res, right - left + 1);
}
return res;
}
}
最小覆盖子串
给你一个字符串 s
、一个字符串 t
。返回 s
中涵盖 t
所有字符的最小子串。如果 s
中不存在涵盖 t
所有字符的子串,则返回空字符串 ""
。
注意:
- 对于
t
中重复字符,我们寻找的子字符串中该字符数量必须不少于t
中该字符数量。 - 如果
s
中存在这样的子串,我们保证它是唯一的答案。
示例 1:
输入:s = "ADOBECODEBANC", t = "ABC"
输出:"BANC"
解释:最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。
示例 2:
输入:s = "a", t = "a"
输出:"a"
解释:整个字符串 s 是最小覆盖子串。
示例 3:
输入: s = "a", t = "aa"
输出: ""
解释: t 中两个字符 'a' 均应包含在 s 的子串中,
因此没有符合条件的子字符串,返回空字符串。
class Solution {
public String minWindow(String s, String t) {
int n = s.length(), tot = 0;
//c1、c2分别用于存储t中字符的次数和窗口内字符的次数,60是足够容纳所有字母种类
int[] c1 = new int[60], c2 = new int[60];
//遍历t中的每个字符,保存每个字符的次数
for (char x : t.toCharArray()) {
//tot表示字符的种类数
if (++c1[getIdx(x)] == 1) tot++;
}
//初始化答案
String ans = "";
//j是窗口左边界,i是窗口右边界
for (int i = 0, j = 0; i < n; i++) {
//得到窗口右边界字符对应的数字下标
int idx1 = getIdx(s.charAt(i));
//每次遍历,就将当前窗口字符的数量保存下来,如果和t字符串的字符数量相等,tot-1表示剩余需要满足要求的字符种类
if (++c2[idx1] == c1[idx1]) tot--;
while (j < i) {
//拿到窗口左边界的字符对应数字下标
int idx2 = getIdx(s.charAt(j));
//不断缩短窗口左边界
if (c2[idx2] > c1[idx2] && --c2[idx2] >= 0) j++;
else break;
}
//符合要求,保存答案
//ans.length()(之前符合的窗口大小) > i - j + 1(当前符合窗口大小)
//如果现在的窗口比之前还大,那没必要更新,因为是取最小的区间
if (tot == 0 && (ans.length() == 0 || ans.length() > i - j + 1)) ans = s.substring(j, i + 1);
}
return ans;
}
//设定好字符对应的数字,作为数组的下标
int getIdx(char x) {
return x >= 'A' && x <= 'Z' ? x - 'A' + 26 : x - 'a';
}
}