滑动窗口算法
作者：互联网
滑动窗口算法
名称
滑动窗口算法
场景
当遇到找出序列中连续子序列满足某些条件的问题的时候,可以使用滑动窗口. 序列包括:数组,字符串,List,链表等.
当我们遇到了求满足目标的连续子序列的时候,第一直觉适用滑动子窗口
解决方案
滑动窗口模板:
//创建双指针
int left= start;
int right= start;
//右指针移动
while(right < end){
将rank=right位置的数据添加到窗口中.
while(!窗口不合规){
// 判断是否满足条件,更新结果.
left++;
}
if(窗口满足最终条件){
更新最终结果.
刷新窗口.
}
right++;
}
返回结果.
效果
满足某个要求的连续子串普通的实现至少是 O(n^2).但是适用滑动窗口能够将问题复杂度降低到 O(n).
实例
问题一 剑指 Offer II 008. 和大于等于 target 的最短子数组
给定一个含有n个正整数的数组和一个正整数 target 。
找出该数组中满足其和 ≥ target 的长度最小的 连续子数组[numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
给定一个含有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 <= 109
1 <= nums.length <= 105
1 <= nums[i] <= 105
进阶：
如果你已经实现 O(n) 时间复杂度的解法, 请尝试设计一个 O(n log(n)) 时间复杂度的解法。
class Solution {
public int minSubArrayLen(int target, int[] nums) {
/**
* 7
* [2,3,1,2,4,3]
*
* 给定一个数组,正整数,找出最短的连续子数组,求出长度最小的连续子序列.
* 满足条件是 子序列的和 >=target
* 求出长度最短的那个
*/
if (nums.length == 0) {
return 0;
}
int left = 0, right = 0;
int minLength = Integer.MAX_VALUE;
int sum = 0;
while (right < nums.length) {
sum += nums[right];
//[left,right]
while (sum >= target) {
minLength = Math.min(minLength, (right - left + 1));
sum -= nums[left];
left++;
}
right++;
}
return minLength == Integer.MAX_VALUE ? 0 : minLength;
}
}
如果使用 nlogn复杂度的算法.这个时候适用累加和,然后用二分查找累加和.
问题二 剑指 Offer II 009. 乘积小于 K 的子数组
给定一个正整数数组nums和整数 k，请找出该数组内乘积小于k的连续的子数组的个数。
示例 1:
输入: nums = [10,5,2,6], k = 100
输出: 8
解释: 8 个乘积小于 100 的子数组分别为: [10], [5], [2], [6], [10,5], [5,2], [2,6], [5,2,6]。
需要注意的是 [10,5,2] 并不是乘积小于100的子数组。
示例 2:
输入: nums = [1,2,3], k = 0
输出: 0
提示:
1 <= nums.length <= 3 * 104
1 <= nums[i] <= 1000
0 <= k <= 106
class Solution {
public int numSubarrayProductLessThanK(int[] nums, int k) {
/**
* 找出所有的连续子数组,其乘积 < target元素
*/
int left = 0, right = 0;
int result = 1;
int count = 0;
while (right < nums.length) {
result *= nums[right];
while (left <= right && result >= k) {
result /= nums[left];
left++;
}
//当前满足了 以nums[right]结尾的子序列的乘积 < k
//这里 count += right - left +1 的思路是 以当前right结尾的所有的子序列.
// 其中 左区间可以是 [right,left].所以是 额外添加的元素是 (right -left +1)
count += right - left + 1;
right++;
}
return count;
}
}
问题三 剑指 Offer II 014. 字符串中的变位词
给定两个字符串s1和s2，写一个函数来判断 s2 是否包含 s1的某个变位词。
换句话说，第一个字符串的排列之一是第二个字符串的 子串 。
示例 1：
输入: s1 = "ab" s2 = "eidbaooo"
输出: True
解释: s2 包含 s1 的排列之一 ("ba").
示例 2：
输入: s1= "ab" s2 = "eidboaoo"
输出: False
提示：
1 <= s1.length, s2.length <= 104
s1 和 s2 仅包含小写字母
class Solution {
public boolean checkInclusion(String s1, String s2) {
/**
* s2是否包括s1的排列
*/
int left = 0, right = 0;
int[] chCount = new int[26];
for (int i = 0; i < s1.length(); i++) {
char ch = s1.charAt(i);
chCount[ch - 'a']++;
}
while (right < s2.length()) {
int rightRank = s2.charAt(right) - 'a';
chCount[rightRank]--;
while (chCount[rightRank] < 0) {
int leftRank = s2.charAt(left) - 'a';
chCount[leftRank]++;
left++;
}
if (right - left + 1 == s1.length()) {
return true;
}
right++;
}
return false;
}
}
这个题首先不断的nums[right]添加窗口并统计计数.依次将nums[left]移出窗口直到窗口合规,然后校验最终结果是否符合条件.
这题是标准的模板实现.
问题四 剑指 Offer II 017. 含有所有字符的最短字符串
给定两个字符串 s 和t 。返回 s 中包含t的所有字符的最短子字符串。如果 s 中不存在符合条件的子字符串，则返回空字符串 "" 。
如果 s 中存在多个符合条件的子字符串，返回任意一个。
注意： 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
示例 1：
输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"
解释：最短子字符串 "BANC" 包含了字符串 t 的所有字符 'A'、'B'、'C'
示例 2：
输入：s = "a", t = "a"
输出："a"
示例 3：
输入：s = "a", t = "aa"
输出：""
解释：t 中两个字符 'a' 均应包含在 s 的子串中，因此没有符合条件的子字符串，返回空字符串。
提示：
1 <= s.length, t.length <= 105
s 和 t 由英文字母组成
进阶：你能设计一个在 o(n) 时间内解决此问题的算法吗？
class Solution {
public String minWindow(String s, String t) {
/**
* 这个题使用滑动窗口,首先适用右侧进行滑动,然后不断判断[left,right]是否满足了条件所有的字母个数都满足了条件.然后移动左侧.知道不满足为止.然后获取[left-1,right]为一个符合条件的字符串.
* 然后右侧继续移动,知道满足条件为止.
*/
Map<Character, Integer> targetChCountMap = new HashMap<>();
for (int i = 0; i < t.length(); i++) {
char ch = t.charAt(i);
targetChCountMap.put(t.charAt(i), targetChCountMap.getOrDefault(ch, 0) + 1);
}
Map<Character, Integer> chCountMap = new HashMap<>();
int left = 0, right = 0;
boolean isLegal = false;
String minLenStr = null;
while (right < s.length()) {
if (!isLegal) {
char rightCh = s.charAt(right);
chCountMap.put(rightCh, chCountMap.getOrDefault(rightCh, 0) + 1);
isLegal = isLegalStr(chCountMap, targetChCountMap);
//right指向了下一个位置
right++;
}
while (left <= right && isLegal) {
char leftCh = s.charAt(left);
chCountMap.put(leftCh, chCountMap.get(leftCh) - 1);
isLegal = isLegalStr(chCountMap, targetChCountMap);
if (!isLegal) {
String targetStr = s.substring(left, right);
if (minLenStr == null || minLenStr.length() > targetStr.length()) {
minLenStr = targetStr;
}
}
left++;
}
}
return minLenStr == null ? "" : minLenStr;
}
private boolean isLegalStr(Map<Character, Integer> chCountMap, Map<Character, Integer> targetChCountMap) {
for (Map.Entry<Character, Integer> entry : targetChCountMap.entrySet()) {
Integer chCount = chCountMap.get(entry.getKey());
if (chCount == null || chCount < entry.getValue()) {
return false;
}
}
return true;
}
}
求cover了包含 t字符串的子串.这个题是这样做的:
1.将nums[right]不断添加到窗口中.直到满足条件
2.然后左移窗口,直到不满足条件来压缩窗口长度,找出最小长度的窗口
3.计算最终结果.
4.循环第一步
问题四 剑指 Offer II 057. 值和下标之差都在给定的范围内
给你一个整数数组 nums 和两个整数k 和 t 。请你判断是否存在 两个不同下标 i 和 j，使得abs(nums[i] - nums[j]) <= t ，同时又满足 abs(i - j) <= k 。
如果存在则返回 true，不存在返回 false。
示例1：
输入：nums = [1,2,3,1], k = 3, t = 0
输出：true
示例 2：
输入：nums = [1,0,1,1], k = 1, t = 2
输出：true
示例 3：
输入：nums = [1,5,9,1,5,9], k = 2, t = 3
输出：false
提示：
0 <= nums.length <= 2 * 104
-231 <= nums[i] <= 231 - 1
0 <= k <= 104
0 <= t <= 231 - 1
class Solution {
public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
/**
* 这个题是:给定一个长度为 k的滑动窗口. 找出 最后一个元素和之前的元素的差值在 [nums[i]-t,nums[i]+t].
*
*/
TreeSet<Long> window = new TreeSet<>();
for (int i = 0; i < nums.length; i++) {
//从window中找出一个 介于 [nums[i] - t , nums[i] +t]的元素.如果有就返回.
Long ceiling = window.ceiling((long) nums[i] - (long) t); //找出 第一个 ceiling >= nums[i] -t的元素
//判断这个元素是否 <= nums[i] + t
if (ceiling != null && ceiling <= (long) nums[i] + (long)t) {
//如果满足条件就返回false
return true;
}
window.add((long) nums[i]);
if (i >= k) {
window.remove((long)nums[i - k]);
}
}
return false;
}
}
这里的区间有点不同,窗口不仅仅使用的是 nums[left,right],同时使用一个TreeSet将窗口数据添加进来,便于处理
标签：right,窗口,nums,int,++,算法,数组,滑动,left 来源： https://www.cnblogs.com/xxuuzz/p/16412296.html