滑动窗口相关算法题总结

最新推荐文章于 2023-12-01 10:34:32 发布

guihunkun

最新推荐文章于 2023-12-01 10:34:32 发布

阅读量4.7k

点赞数 6

分类专栏：算法与数据结构文章标签：算法 leetcode c++

本文链接：https://blog.csdn.net/guihunkun/article/details/109266185

版权

算法与数据结构专栏收录该内容

15 篇文章 1 订阅

订阅专栏

文章目录

前言

滑动窗口算法可以将嵌套的循环问题，转换为单循环问题，降低时间复杂度。

算法题

1. LeetCode 1423. 可获得的最大点数

LeetCode 1423

几张卡牌排成一行，每张卡牌都有一个对应的点数。点数由整数数组 cardPoints 给出。
每次行动，你可以从行的开头或者末尾拿一张卡牌，最终你必须正好拿 k 张卡牌。
你的点数就是你拿到手中的所有卡牌的点数之和。
给你一个整数数组 cardPoints 和整数 k，请你返回可以获得的最大点数。
示例 1：
输入：cardPoints = [1,2,3,4,5,6,1], k = 3
输出：12
解释：第一次行动，不管拿哪张牌，你的点数总是 1 。但是，先拿最右边的卡牌将会最大化你的可获得点数。最优策略是拿右边的三张牌，最终点数为 1 + 6 + 5 = 12 。
示例 2：
输入：cardPoints = [2,2,2], k = 2
输出：4
解释：无论你拿起哪两张卡牌，可获得的点数总是 4 。
示例 3：
输入：cardPoints = [9,7,7,9,7,7,9], k = 7
输出：55
解释：你必须拿起所有卡牌，可以获得的点数为所有卡牌的点数之和。
示例 4：
输入：cardPoints = [1,1000,1], k = 1
输出：1
解释：你无法拿到中间那张卡牌，所以可以获得的最大点数为 1 。
示例 5：
输入：cardPoints = [1,79,80,1,1,1,200,1], k = 3
输出：202
提示：
1 <= cardPoints.length <= 10^5
1 <= cardPoints[i] <= 10^4
1 <= k <= cardPoints.length

/*
 * 1
 * LeetCode 1423. 可获得的最大点数
 * https://leetcode-cn.com/problems/maximum-points-you-can-obtain-from-cards/
 */
int maxScore(vector<int>& cardPoints, int k)
{
    // 求两边最大值，就是求中间的最小值，即以求中间的数组连续部分的最小值
    int sum = 0;
    for(auto num : cardPoints)
    {
        sum += num;
    }
    int n = cardPoints.size();
    int window = 0;
    for(int i = 0; i < n - k; i++)
    {
        window += cardPoints[i];
    }
    int minW = window;
    for(int i = n-k; i < n; i++)
    {
        window += cardPoints[i];
        window -= cardPoints[i-n+k];
        minW = min(minW, window);
    }
    return sum - minW;
}

2. LeetCode 3 : 无重复字符的最长子串

LeetCode 3

给定一个字符串，请你找出其中不含有重复字符的最长子串的长度。
示例 1:
输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:
输入: “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:
输入: “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是子串的长度，“pwke” 是一个子序列，不是子串。

/*
 * 2
 * LeetCode 3 : 无重复字符的最长子串
 * https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/
 */
int lengthOfLongestSubstring(string s)
{
    set<char> record;
    int res=0,left=0,right=0;
    while(right<s.size())
    {
        if(record.find(s[right])==record.end())
        {
            record.insert(s[right++]);
            res=max(res,(int)record.size());
        }
        else
        {
            record.erase(s[left++]);
        }
    }
    return res;
}

3. LeetCode 1004 : 最大连续1的个数 III

LeetCode 1004

给定一个由若干 0 和 1 组成的数组 A，我们最多可以将 K 个值从 0 变成 1 。
返回仅包含 1 的最长（连续）子数组的长度。
示例 1：
输入：A = [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：
输入：A = [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。
提示：
1 <= A.length <= 20000
0 <= K <= A.length
A[i] 为 0 或 1

/*
 * 3
 * LeetCode 1004 : 最大连续1的个数 III
 * https://leetcode-cn.com/problems/max-consecutive-ones-iii/
 */
int longestOnes(vector<int>& nums, int k)
{
    //使从区间[l , r] 内部0的数量不超过k就行
    int l = 0,r = 0, ans = 0, cnt = 0;
    while(r < nums.size())
    {
        if(nums[r] == 0)
            cnt++;
        if(cnt > k)
        {
            if(nums[l] == 0)
                cnt--;
            l++;
        }
        ans = max(ans, r-l+1);
        r++;
    }
    return ans;
}

4. LeetCode 1438 : 绝对差不超过限制的最长连续子数组

LeetCode 1438

给你一个整数数组 nums ，和一个表示限制的整数 limit，请你返回最长连续子数组的长度，该子数组中的任意两个元素之间的绝对差必须小于或者等于 limit 。
如果不存在满足条件的子数组，则返回 0 。
示例 1：
输入：nums = [8,2,4,7], limit = 4
输出：2
解释：所有子数组如下：
[8] 最大绝对差 |8-8| = 0 <= 4.
[8,2] 最大绝对差 |8-2| = 6 > 4.
[8,2,4] 最大绝对差 |8-2| = 6 > 4.
[8,2,4,7] 最大绝对差 |8-2| = 6 > 4.
[2] 最大绝对差 |2-2| = 0 <= 4.
[2,4] 最大绝对差 |2-4| = 2 <= 4.
[2,4,7] 最大绝对差 |2-7| = 5 > 4.
[4] 最大绝对差 |4-4| = 0 <= 4.
[4,7] 最大绝对差 |4-7| = 3 <= 4.
[7] 最大绝对差 |7-7| = 0 <= 4.
因此，满足题意的最长子数组的长度为 2 。
示例 2：
输入：nums = [10,1,2,4,7,2], limit = 5
输出：4
解释：满足题意的最长子数组是 [2,4,7,2]，其最大绝对差 |2-7| = 5 <= 5 。
示例 3：
输入：nums = [4,2,2,2,4,4,2,2], limit = 0
输出：3
提示：
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
0 <= limit <= 10^9

/*
 * 4
 * LeetCode 1438 : 绝对差不超过限制的最长连续子数组
 * https://leetcode-cn.com/problems/longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit/
 */
int longestSubarray(vector<int>& nums, int limit)
{
    // multiset能时刻保证序列中的数是有序的，而且序列中可以存在重复的数。
    multiset<int> s;
    int ans = 0;
    int i = 0;
    for(int j = 0; j < nums.size(); j++)
    {
        s.insert(nums[j]);
        while(*s.rbegin() - *s.begin() > limit)
        {
            s.erase(s.find(nums[i]));
            i++;
        }
        ans = max(ans, j - i + 1);
    }
    return ans;
}

5. LeetCode 76 : 最小覆盖子串

LeetCode 76

给你一个字符串 S、一个字符串 T 。请你设计一种算法，可以在 O(n) 的时间复杂度内，从字符串 S 里面找出：包含 T 所有字符的最小子串。
示例：
输入：S = “ADOBECODEBANC”, T = “ABC”
输出：“BANC”
提示：
如果 S 中不存这样的子串，则返回空字符串 “”。
如果 S 中存在这样的子串，我们保证它是唯一的答案。

/*
 * 5
 * LeetCode 76 : 最小覆盖子串
 * https://leetcode-cn.com/problems/minimum-window-substring/
 */
string minWindow(string s, string t)
{
    /*
     * 滑动窗口:，首先左右指针指向S的开头，然后右指针右移直到可以包含T，
     * 这个时候记录下来子字符串的长度，然后左指针左移，判断当前子字符串是否包含T，
     * 直到左指针左移到不包含T为止。然后右指针右移。
     */
    unordered_map<char, int> rec;
    for(auto c : t)
        rec[c] ++;
    int len = 0, n = s.size();
    int minlen = n;
    string res = "";
    int l = 0, r = 0;
    for( ; r < n; r++)
    {
        rec[s[r]]--;
        if(rec[s[r]] >= 0)
            len++;
        while(len == t.size())
        {
            if(r - l + 1 <= minlen)
            {
                minlen = r - l + 1;
                res = s.substr(l, r - l + 1);
            }
            rec[s[l]] ++;
            if(rec[s[l]] > 0)
                len--;
            l++;
        }
    }
    return res;
}