目录
一、长度最小的子数组
1.题目链接：209.长度最小的子数组
2.题目描述：
给定一个含有
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提示：
1 <= target <= 1091 <= nums.length <= 1051 <= nums[i] <= 105
3.解法一（暴力解法、会超时）
🌻算法思路：
- 「从前往后」枚举数组中的任意一个元素，把它当成起始位置。然后从这个「起始位置」开始，然后寻找一段最短的区间，使得这段区间的和「大于等于」目标值。
- 将所有元素作为起始位置所得的结果中，找到「最小值」即可。
🌻算法代码：
class Solution
{
public:
int minSubArrayLen(int target, vector<int>& nums)
{
int n = nums.size();
// 记录结果
int ret = INT_MAX;
// 枚举出所有满⾜和⼤于等于 target 的⼦数组[start, end]
// 由于是取到最⼩，因此枚举的过程中要尽量让数组的⻓度最⼩
// 枚举开始位置
for (int start = 0; start < n; start++)
{
// 记录从这个位置开始的连续数组的和
int sum = 0;
// 寻找结束位置
for (int end = start; end < n; end++)
{
sum += nums[end]; // 将当前位置加上
if (sum >= target) // 当这段区间内的和满⾜条件时
{
// 更新结果，start 开头的最短区间已经找到
ret = min(ret, end - start + 1);
break;
}
}
}
// 返回最后结果
return ret == INT_MAX ? 0 : ret;
}
};4.解法二（滑动窗口）
🌻算法思路：
由于此问题分析的对象是「一段连续的区间」，因此可以考虑「滑动窗口（单调性与同向双指针同时满足）」的思想来解决这道题。
让滑动窗口满足：从 i 位置开始，窗口内所有元素的和小于 target （那么当窗口内元素之和第一次大于等于目标值的时候，就是 i 位置开始，满足条件的最小长度）。
做法：将右端元素划入窗口中，统计出此时窗口内元素的和：
- 如果窗口内元素之和大于等于 target ：更新结果，并且将左端元素划出去的同时继续判断是否满足条件并更新结果（因为左端元素可能很小，划出去之后依旧满足条件）
- 如果窗口内元素之和不满足条件： right++ ，令下一个元素进入窗口。
为何滑动窗口可以解决问题，并且时间复杂度更低？
- 这个窗口寻找的是：以当前窗口最左侧元素（记为 left1 ）为基准，符合条件的情况。也就是在这道题中，从 left1 开始，满足区间和 sum >= target 时的最右侧（记为right1 ）能到哪里。
- 我们既然已经找到从 left1 开始的最优的区间，那么就可以大胆舍去 left1 。但是如果继续像方法一一样，重新开始统计第二个元素（ left2 ）往后的和，势必会有大量重复的计算（因为我们在求第一段区间的时候，已经算出很多元素的和了，这些和是可以在计算下次区间和的时候用上的）。
- 此时， rigth1 的作用就体现出来了，我们只需将 left1 这个值从 sum 中剔除。从right1 这个元素开始，往后找满足 left2 元素的区间（此时 right1 也有可能是满足的，因为 left1 可能很小。 sum 剔除掉 left1 之后，依旧满足大于等于target ）。这样我们就能省掉大量重复的计算。
- 这样我们不仅能解决问题，而且效率也会大大提升。
时间复杂度：虽然代码是两层循环，但是我们的 left 指针和 right 指针都是不回退的，两者最多都往后移动 n 次。因此时间复杂度是 O(N) 。
🌻算法代码：
class Solution
{
public:
int minSubArrayLen(int target, vector<int>& nums)
{
int n = nums.size(), sum = 0, len = INT_MAX;
for(int left = 0, right = 0; right < n; right++)
{
sum += nums[right]; // 进窗口
while(sum >= target) // 判断
{
len = min(len, right - left + 1); // 更新结果
sum -= nums[left++]; // 出窗口
}
}
return len == INT_MAX ? 0 : len;
}
};二、无重复字符的最长子串
1.题目链接：3.无重复字符的最长子串
2.题目描述：
给定一个字符串
s，请你找出其中不含有重复字符的 最长子串 的长度。示例 1:
输入: s = "abcabcbb" 输出: 3 解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。示例 2:
输入: s = "bbbbb" 输出: 1 解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。示例 3:
输入: s = "pwwkew" 输出: 3 解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。 请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
3.解法一（暴力解法、会超时）
🍃算法思路：
枚举「从每一个位置」开始往后，无重复字符的子串可以到达什么位置。找出其中长度最大的即可。
在往后寻找无重复子串能到达的位置时，可以利用「哈希表」统计出字符出现的频次，来判断什么时候子串出现了重复元素。
🍃算法代码：
class Solution
{
public:
int lengthOfLongestSubstring(string s)
{
int n = s.size(), ret = 0;
// 1. 枚举从不同位置开始的最⻓重复⼦串
// 枚举起始位置
for(int i = 0; i < n; i++)
{
// 创建⼀个哈希表，统计频次
int hash[128] = {0};
// 寻找结束为⽌
for(int j = i; j < n; j++)
{
hash[s[j]]++;// 统计字符出现的频次
if(hash[s[j]] > 1)// 判断，如果出现重复的
break;
// 如果没有重复，就更新 ret
ret = max(ret, j - i + 1);
}
}
// 2.返回结果
return ret;
}
};4.解法二（滑动窗口）
🍃算法思路：
研究的对象依旧是一段连续的区间，因此继续使用「滑动窗口」思想来优化。
让滑动窗口满足：窗口内所有元素都是不重复的。
做法：右端元素 ch 进⼊窗口的时候，哈希表统计这个字符的频次：
- 如果这个字符出现的频次超过 1 ，说明窗⼝内有重复元素，那么就从左侧开始划出窗⼝，直到 ch 这个元素的频次变为 1 ，然后再更新结果。
- 如果没有超过 1 ，说明当前窗⼝没有重复元素，可以直接更新结果
🍃算法代码：
class Solution
{
public:
int lengthOfLongestSubstring(string s)
{
int hash[128] = {0};// 使用数组来模拟哈希表
int n = s.size(), ret = 0;
for(int left = 0, right = 0; right < n; right++)
{
hash[s[right]]++;// 进窗口
while(hash[s[right]] > 1)// 判断
{
hash[s[left++]]--;// 出窗口
}
ret = max(ret, right - left + 1);// 更新结果
}
return ret;
}
};三、最大连续 1 的个数 III
1.题目链接：1004.最大连续1的个数III
2.题目描述：
给定一个二进制数组
nums和一个整数k，如果可以翻转最多k个0，则返回 数组中连续1的最大个数 。示例 1：
输入：nums = [1,1,1,0,0,0,1,1,1,1,0], K = 2 输出：6 解释：[1,1,1,0,0,1,1,1,1,1,1] 粗体数字从 0 翻转到 1，最长的子数组长度为 6。示例 2：
输入：nums = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3 输出：10 解释：[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1] 粗体数字从 0 翻转到 1，最长的子数组长度为 10。
3.解法（滑动窗口）
🍀算法思路：
不要去想怎么翻转，不要把问题想的很复杂，这道题的结果无非就是一段连续的 1 中间塞了 k 个 0 嘛。因此，我们可以把问题转化成：求数组中一段最长的连续区间，要求这段区间内 0 的个数不超过 k 个。既然是连续区间，可以考虑使用「滑动窗口」来解决问题。
🍀算法流程：
a. 初始化一个大小为 2 的数组就可以当做哈希表 hash 了；初始化一些变量 left = 0 ,right = 0 , ret= 0 ；
b. 当 right 小于数组大小的时候，一直下列循环：
- 让当前元素进入窗口，顺便统计到哈希表中；
- 检查 0 的个数是否超标：
- 如果超标，依次让左侧元素滑出窗⼝，顺便更新哈希表的值，直到 0 的个数恢复正常；
- 程序到这里，说明窗⼝内元素是符合要求的，更新结果；
- right++ ，处理下一个元素；
c. 循环结束后， ret 存的就是最终结果。
🍀算法代码：
class Solution
{
public:
int longestOnes(vector<int>& nums, int k)
{
int ret = 0;
for(int left = 0, right = 0, zero = 0; right < nums.size(); right++)
{
if(nums[right] == 0) zero++;// 进窗口
while(zero > k)// 判断
if(nums[left++] == 0) zero--;// 出窗口
ret = max(ret, right - left + 1);// 更新结果
}
return ret;
}
};四、将 x 减到 0 的最小操作数
1.题目链接：1658.将x减到0的最小操作数
2.题目描述：
给你一个整数数组
nums和一个整数x。每一次操作时，你应当移除数组nums最左边或最右边的元素，然后从x中减去该元素的值。请注意，需要 修改 数组以供接下来的操作使用。如果可以将
x恰好 减到0，返回 最小操作数 ；否则，返回-1。示例 1：
输入：nums = [1,1,4,2,3], x = 5 输出：2 解释：最佳解决方案是移除后两个元素，将 x 减到 0 。示例 2：
输入：nums = [5,6,7,8,9], x = 4 输出：-1示例 3：
输入：nums = [3,2,20,1,1,3], x = 10 输出：5 解释：最佳解决方案是移除后三个元素和前两个元素（总共 5 次操作），将 x 减到 0 。
3.解法（滑动窗口）
🌲算法思路：
题目要求的是数组「左端+右端」两段连续的、和为 x 的最短数组，信息量稍微多一些，不易理清思路；我们可以转化成求数组内一段连续的、和为 sum(nums) - x 的最长数组。此时，就是熟悉的「滑动窗口」问题了。
🌲算法流程：
a. 转化问题：求 target = sum(nums) - x 。如果 target < 0 ，问题无解；
b. 初始化左右指针 l = 0 , r = 0 （滑动窗口区间表示为 [l, r) ，左右区间是否开闭很重要，必须设定与代码一致），记录当前滑动窗口内数组和的变量 sum = 0 ，记录当前满足条件数组的最大区间长度 maxLen = -1 ；
c. 当 r 小于等于数组长度时，一直循环：
- 如果 sum < target ，右移右指针，直至变量和大于等于 target ，或右指针已经移到头；
- 如果 sum > target ，右移左指针，直至变量和小于等于 target ，或左指针已经移到头；
- 如果经过前两步的左右移动使得 sum == target ，维护满足条件数组的最大长度，并让下个元素进入窗口；
d. 循环结束后，如果 maxLen 的值有意义，则计算结果返回；否则，返回 -1 。
🌲算法代码：
class Solution
{
public:
int minOperations(vector<int>& nums, int x)
{
int sum = 0;
for(int a : nums)
sum += a;
int target = sum - x;
if(target < 0)// 细节
return -1;
int ret = -1;
for(int left = 0, right = 0, tmp = 0; right < nums.size(); right++)
{
tmp += nums[right];// 进窗口
while(tmp > target)// 判断
tmp -= nums[left++];// 出窗口
if(tmp == target)// 更新结果
ret = max(ret, right - left + 1);
}
if(ret == -1) return ret;
else return nums.size() - ret;
}
};
1228
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
