文章介绍了滑动窗口算法在解决LeetCode题目中的应用，包括如何用双指针优化暴力解法，如找到长度最小的子数组、计算水果成篮的最长连续子串和最小覆盖子串。通过对比暴力解法，展示了滑动窗口方法的时间复杂度降低至O(n)的效率提升。
跟着代码随想录学一下。
滑动窗口就是一个特殊的双指针法，在暴力的基础上，用一趟循环两个指针来解决问题。窗口就是一个区间，有区间起点和终点，用两个指针记录。要用一趟循环解决，那么终点指针应该在外层，起点指针在内层。外层的终点指针先右移直到满足条件，此时内层的起点指针右移缩小窗口看是否依然满足条件。直到不满足，返回此时的起点和终点指针，也就找到了最小窗口。
第一题
2023.10.11
LeetCode 209. 长度最小的子数组
暴力解法：
class Solution {
public int minSubArrayLen(int target, int[] nums) {
// 暴力解法
int result = Integer.MAX_VALUE; // 最终的结果
int sum = 0; // 区间的和
int subLength = 0; // 子区间的长度
for (int i = 0; i < nums.length; i++) {
sum = 0;
// j = i;每次都从i及i之后重新看区间
for (int j = i; j < nums.length; j++) {
sum = sum + nums[j];
// 如果sum>target，更新result
if (sum >= target) {
subLength = j - i + 1;
// 返回最小的子区间，长度满足就返回
result = result < subLength ? result : subLength;
// 跳出了当前i后的j求和循环（跳到外层循环）
break;
}
}
}
return result == Integer.MAX_VALUE ? 0 : result;
}
}
时间复杂度：O(n²)
空间复杂度：O(1)
滑动窗口
class Solution {
public int minSubArrayLen(int target, int[] nums) {
// 滑动窗口（双指针法的一种）
int result = Integer.MAX_VALUE;
int sum = 0;
int subLength = 0;
int i = 0; // 窗口起始位置
// 唯一的 for 循环，j 表示终止位置，如果 j 是起始位置，实际又会变成暴力
for (int j = 0; j < nums.length; j++) { // j++ 终止位置右移
// 区间和
sum += nums[j];
while (sum >= target) {
// 每次满足条件，要把最小的subLength记到result中
subLength = j - i + 1;
result = result < subLength ? result : subLength;
// 起始位置右移，和减去原起始位置的值，以始终保持为窗口的和
sum -= nums[i++];
// j先右移到sum>=target，此时i还在0，
// 然后i也不断右移，每次都把最小的subLength更新到result中，
// 直到sum不再>=target，又继续到外层for循环去看后面的j，
// 如是重复直到j遍历完数组，记下的result也就是最小的了
}
}
return result == Integer.MAX_VALUE ? 0 : result;
}
}
时间复杂度：O(n)
空间复杂度：O(1)
第二题
904. 水果成篮
暴力解法
2023.10.14（出了点问题，今天继续）
class Solution {
// 任意两个数字的最长连续子串
public int totalFruit(int[] fruits) {
int maxFruits = 0;
for (int i = 0; i < fruits.length; i++) {
int count = 0;
int a = -1;
int b = -1;
for (int j = i; j < fruits.length; j++) {
if (fruits[j] == a || fruits[j] == b) {
// 如果水果类型与a或b相同，继续
count++;
} else if (a == -1) {
a = fruits[j];
count++;
} else if (b == -1) {
b = fruits[j];
count++;
} else {
// 如果遇到第三种水果，跳出内层循环
break;
}
}
maxFruits = Math.max(maxFruits, count);
}
return maxFruits;
}
}
滑动窗口
class Solution {
public int totalFruit(int[] fruits) {
int maxFruits = 0; // 用于记录最长子数组的长度
int left = 0; // 左指针，窗口的起始位置
Map<Integer, Integer> fruitCount = new HashMap<>(); // 用于记录窗口内水果的数量
for (int right = 0; right < fruits.length; right++) {
int fruit = fruits[right];
fruitCount.put(fruit, fruitCount.getOrDefault(fruit, 0) + 1); // 将当前水果添加到窗口内
// 如果窗口内的水果种类数大于2，需要收缩窗口
while (fruitCount.size() > 2) {
int leftFruit = fruits[left]; // 获取窗口左边的水果
fruitCount.put(leftFruit, fruitCount.get(leftFruit) - 1); // 减少左边水果的数量
if (fruitCount.get(leftFruit) == 0) {
fruitCount.remove(leftFruit); // 如果左边水果数量为0，从窗口内移除
}
left++; // 收缩窗口
}
// 更新最长子数组的长度
maxFruits = Math.max(maxFruits, right - left + 1);
}
return maxFruits;
}
}
第三题
2023.10.14
76. 最小覆盖子串
暴力解法
class Solution {
public String minWindow(String s, String t) {
// 暴力解法
if (s.length() < t.length()) return "";
int minSubStrLen = Integer.MAX_VALUE; // 子串长度
String minContainStr = ""; // 结果字符串
// 两层for循环s
for (int left = 0; left < s.length(); left++) {
for (int right = left; right < s.length(); right++) {
String subStr = s.substring(left, right + 1); // 左闭右开，所以+1
// 判断t是否在子串内都有
if (containAll(subStr, t) && subStr.length() < minSubStrLen) {
// 更新最小长度和符合的最小长度字符串
minContainStr = subStr;
minSubStrLen = subStr.length();
}
}
}
return minContainStr;
}
private boolean containAll(String subStr, String t) {
// 使用数组来记录subStr和t的每个字符出现的次数
int[] subStrCharCount = new int[256]; // 256是ASCII码的常用字符
int[] tCharCount = new int[256];
for (char c : t.toCharArray()) {
tCharCount[c]++; // c的ASCII码为索引，该处的值+1
}
for (char c : subStr.toCharArray()) {
subStrCharCount[c]++;
}
// 检查子串是否包含了t的所有字符
for (char c : t.toCharArray()) {
if (subStrCharCount[c] < tCharCount[c]) {
return false;
}
}
return true;
}
}
时间复杂度：O(n² × m)
空间复杂度：O(1) —— 常数个变量，虽然用了两个数组，但是256是为了对应ASCII码，与t或者subStr的长度无关，所以也是常数级。
滑动窗口1：
class Solution {
public String minWindow(String s, String t) {
if (s.length() < t.length()) return "";
// 使用字符数组来记录目标字符串t中每个字符的出现次数
int[] targetCharCount = new int[256];
for (char c : t.toCharArray()) targetCharCount[c]++;
int left = 0; // 左边界
int minLen = Integer.MAX_VALUE; // 记录最小子串长度
int minLeft = 0; // 记录最小子串的起始位置
int count = t.length(); // 记录尚未覆盖的目标字符数量
int right = 0; // 右边界，初始化为0
int[] windowCharCount = new int[256]; // 当前窗口的字符计数数组
while (right < s.length()) {
char rightChar = s.charAt(right);
// 更新窗口内字符的计数
windowCharCount[rightChar]++;
// 如果字符在目标中且在窗口内的计数匹配目标计数
if (targetCharCount[rightChar] > 0 &&
windowCharCount[rightChar] <= targetCharCount[rightChar]) count--;
// 当所有目标字符都在窗口内
while (count == 0) {
// 更新最小子串信息
if (right - left + 1 < minLen) {
minLen = right - left + 1;
minLeft = left;
}
// 移动左边界
char leftChar = s.charAt(left);
windowCharCount[leftChar]--;
if (targetCharCount[leftChar] > 0 &&
windowCharCount[leftChar] < targetCharCount[leftChar]) count++;
left++;
}
right++; // 扩展窗口
}
// 如果找到了最小子串，返回它；否则，返回空字符串
return minLen == Integer.MAX_VALUE ? "" : s.substring(minLeft, minLeft + minLen);
}
}
滑动窗口2
和上一个差不多，只是直接拿targetCharCount作windowCharCount去实现窗口长度统计了
class Solution {
public String minWindow(String s, String t) {
if (s.length() < t.length()) return "";
// 使用字符数组记录目标字符串t中每个字符的出现次数
int[] targetCharCount = new int[256];
for (char c : t.toCharArray()) targetCharCount[c]++;
int left = 0; // 左边界
int minLen = Integer.MAX_VALUE; // 记录最小子串长度
int minLeft = 0; // 记录最小子串的起始位置
int count = t.length(); // 记录尚未覆盖的目标字符数量
// 右边界从0开始逐渐增加
for (int right = 0; right < s.length(); right++) {
char rightChar = s.charAt(right);
// 如果目标字符中包含当前字符，减少count
if (targetCharCount[rightChar] > 0) count--;
// 减少目标字符计数
targetCharCount[rightChar]--;
// 当count等于0时，说明当前窗口包含了所有目标字符
while (count == 0) {
// 更新最小子串信息
if (right - left + 1 < minLen) {
minLen = right - left + 1;
minLeft = left;
}
// 左边界向右移动，增加目标字符计数
char leftChar = s.charAt(left);
targetCharCount[leftChar]++;
if (targetCharCount[leftChar] > 0) count++;
left++;
}
}
// 如果找到了最小子串，返回它
if (minLen == Integer.MAX_VALUE) return "";
return s.substring(minLeft, minLeft + minLen);
}
}
212
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
