【秒杀考研数据结构+考研复试上机】day2.滑动窗口+前缀和习题+数组专题总结

本文链接：https://blog.youkuaiyun.com/coooode_king/article/details/145329052

209.长度最小的子数组

力扣题目链接(opens new window)

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

输入：s = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

提示：

1 <= target <= 10^9
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^5

思路

#暴力解法

这道题目暴力解法当然是两个for循环，然后不断的寻找符合条件的子序列，时间复杂度很明显是O(n^2)。

代码如下：

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int result = INT32_MAX; // 最终的结果
        int sum = 0; // 子序列的数值之和
        int subLength = 0; // 子序列的长度
        for (int i = 0; i < nums.size(); i++) { // 设置子序列起点为i
            sum = 0;
            for (int j = i; j < nums.size(); j++) { // 设置子序列终止位置为j
                sum += nums[j];
                if (sum >= s) { // 一旦发现子序列和超过了s，更新result
                    subLength = j - i + 1; // 取子序列的长度
                    result = result < subLength ? result : subLength;
                    break; // 因为我们是找符合条件最短的子序列，所以一旦符合条件就break
                }
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result;
    }
};

时间复杂度：O(n^2)
空间复杂度：O(1)

后面力扣更新了数据，暴力解法已经超时了。

#滑动窗口

接下来就开始介绍数组操作中另一个重要的方法：滑动窗口。

所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。

在暴力解法中，是一个for循环滑动窗口的起始位置，一个for循环为滑动窗口的终止位置，用两个for循环完成了一个不断搜索区间的过程。

那么滑动窗口如何用一个for循环来完成这个操作呢。

首先要思考如果用一个for循环，那么应该表示滑动窗口的起始位置，还是终止位置。

如果只用一个for循环来表示滑动窗口的起始位置，那么如何遍历剩下的终止位置？

此时难免再次陷入暴力解法的怪圈。

所以 只用一个for循环，那么这个循环的索引，一定是表示滑动窗口的终止位置。

那么问题来了，滑动窗口的起始位置如何移动呢？

这里还是以题目中的示例来举例，s=7，数组是 2，3，1，2，4，3，来看一下查找的过程：

209.长度最小的子数组

最后找到 4，3 是最短距离。

其实从动画中可以发现滑动窗口也可以理解为双指针法的一种！只不过这种解法更像是一个窗口的移动，所以叫做滑动窗口更适合一些。

在本题中实现滑动窗口，主要确定如下三点：

窗口内是什么？
如何移动窗口的起始位置？
如何移动窗口的结束位置？

窗口就是满足其和 ≥ s 的长度最小的连续子数组。

窗口的起始位置如何移动：如果当前窗口的值大于等于s了，窗口就要向前移动了（也就是该缩小了）。

窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，也就是for循环里的索引。

解题的关键在于窗口的起始位置如何移动，如图所示：

leetcode_209

可以发现滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)暴力解法降为O(n)。

C++代码如下：

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int result = INT32_MAX;
        int sum = 0; // 滑动窗口数值之和
        int i = 0; // 滑动窗口起始位置
        int subLength = 0; // 滑动窗口的长度
        for (int j = 0; j < nums.size(); j++) {
            sum += nums[j];
            // 注意这里使用while，每次更新 i（起始位置），并不断比较子序列是否符合条件
            while (sum >= s) {
                subLength = (j - i + 1); // 取子序列的长度
                result = result < subLength ? result : subLength;
                sum -= nums[i++]; // 这里体现出滑动窗口的精髓之处，不断变更i（子序列的起始位置）
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result;
    }
};

时间复杂度：O(n)
空间复杂度：O(1)

一些录友会疑惑为什么时间复杂度是O(n)。

不要以为for里放一个while就以为是O(n^2)啊，主要是看每一个元素被操作的次数，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n 也就是O(n)。

#相关题目推荐

59.螺旋矩阵II

力扣题目链接(opens new window)

给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

示例:

输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

思路

这道题目可以说在面试中出现频率较高的题目，本题并不涉及到什么算法，就是模拟过程，但却十分考察对代码的掌控能力。

要如何画出这个螺旋排列的正方形矩阵呢？

相信很多同学刚开始做这种题目的时候，上来就是一波判断猛如虎。

结果运行的时候各种问题，然后开始各种修修补补，最后发现改了这里那里有问题，改了那里这里又跑不起来了。

大家还记得我们在这篇文章数组：每次遇到二分法，都是一看就会，一写就废 (opens new window)中讲解了二分法，提到如果要写出正确的二分法一定要坚持循环不变量原则。

而求解本题依然是要坚持循环不变量原则。

模拟顺时针画矩阵的过程:

填充上行从左到右
填充右列从上到下
填充下行从右到左
填充左列从下到上

由外向内一圈一圈这么画下去。

可以发现这里的边界条件非常多，在一个循环中，如此多的边界条件，如果不按照固定规则来遍历，那就是一进循环深似海，从此offer是路人。

这里一圈下来，我们要画每四条边，这四条边怎么画，每画一条边都要坚持一致的左闭右开，或者左开右闭的原则，这样这一圈才能按照统一的规则画下来。

那么我按照左闭右开的原则，来画一圈，大家看一下：

这里每一种颜色，代表一条边，我们遍历的长度，可以看出每一个拐角处的处理规则，拐角处让给新的一条边来继续画。

这也是坚持了每条边左闭右开的原则。

一些同学做这道题目之所以一直写不好，代码越写越乱。

就是因为在画每一条边的时候，一会左开右闭，一会左闭右闭，一会又来左闭右开，岂能不乱。

代码如下，已经详细注释了每一步的目的，可以看出while循环里判断的情况是很多的，代码里处理的原则也是统一的左闭右开。

代码整体框架:

vector<vector<int>> generateMatrix(int n) {
    // 1. 准备一个 n x n 的二维数组，用于存放结果
    vector<vector<int>> res(n, vector<int>(n, 0));

    // 2. 定义起始位置 (startx, starty)，从矩阵的左上角(0, 0)开始
    int startx = 0, starty = 0;

    // 3. 这个 loop 表示外层要转多少圈（“螺旋圈”）
    //   如果 n=3，实际上只需要转 1 圈(最外层)，然后中间那个位置单独处理。
    //   如果 n=4，则需要转2圈(第一圈是外圈，第二圈是内圈)……
    int loop = n / 2;

    // 4. 如果 n 是奇数，矩阵中间会有一个单独的点，需要最后补上
    //   例如 n=3 的中间点在 (1,1)，n=5 的中间点在 (2,2)
    int mid = n / 2;

    // 5. count 用来给矩阵中的每个格子赋值，从 1 开始，依次递增
    int count = 1;

    // 6. offset 这个参数，用来控制每一条边遍历的“终止”位置
    //   简单来说，每圈都要少走一点，因为边界收缩了
    int offset = 1;

    // 7. 开始正式的“每圈循环”
    //    只要 loop > 0，就表示我们还有“外层圈”没填完
    while (loop--) {
        // 准备从起始坐标走动
        int i = startx;
        int j = starty;

        // （1）上边，从左到右
        for (; j < n - offset; j++) {
            res[i][j] = count++;
        }

        // （2）右边，从上到下
        for (; i < n - offset; i++) {
            res[i][j] = count++;
        }

        // （3）下边，从右到左
        for (; j > starty; j--) {
            res[i][j] = count++;
        }

        // （4）左边，从下到上
        for (; i > startx; i--) {
            res[i][j] = count++;
        }

        // 这一圈走完之后，下一圈的起始位置要往内挪：
        startx++;
        starty++;

        // offset 加 1，因为我们已经把最外面的一圈填完了，下一圈要少走一点
        offset++;
    }

    // 如果 n 是奇数，把中间的那个点补上
    if (n % 2 == 1) {
        res[mid][mid] = count;
    }
    return res;
}

重点放在“循环”上,让我们拆开来看

循环次数：`while(loop--)`

loop 最初是 n/2，意思是这个螺旋矩阵最外层、次外层……需要转多少“圈”。
每转一圈，就减少 1，直到变成 0 为止。

比如：

当 n=3 的时候，loop = 3/2 = 1 (整数除法只取整)，只需要转最外面那一圈，内部就只剩一个点要手动补上。
当 n=5 的时候，loop = 5/2 = 2，意味着要转两圈(外圈+内圈)，剩下的最中间一个点再手动补上。

每一圈开始前的坐标：`int i = startx; int j = starty;`

比如第一圈时， startx = 0, starty = 0，就从左上角(0,0)开始转。
转完这一圈后，就把 startx、starty 都加 1，下一圈就从(1,1)这个位置继续转。

为什么有 `offset`？

offset 用来控制每一圈里，最右边或最下边到底要走到什么位置。
第一次最外圈，我们希望把列走到最右边（索引 n-1），行走到最下面（索引 n-1）。但是由于四个 for 循环写在一起，代码中把“结束位置”用了 (n - offset) 这种形式，每一圈转完后 offset++，下一圈就会少走一点。

一个更直观理解：

第一圈(最外层)：最右边索引是 n-1，最下边索引是 n-1。
第二圈：最右边和最下边就要往里缩1格，也就是要走到 n-2。
第三圈：要走到 n-3，依此类推……
于是就把这个往里缩的量归纳成了一个变量 offset，每转一圈就 offset++ 来代表“右下边界又缩进了1格”。

四个 for 循环的含义

这是螺旋的核心逻辑：如何让我们在一圈里，沿着四条边去填值？

(1) 上边：从左到右

// i固定不变 = startx
// j从 starty 一直走到 n-offset (不包含 n-offset 本身吗？要看 "<" 还是 "<=")
for (; j < n - offset; j++) {
    res[i][j] = count++;
}

举例：假设这是第一圈，startx = starty = 0， offset = 1，那 j < n - offset 就是 j < n - 1，也就是 j 最多跑到 n-2，这个和要不要包含右端点可以具体看需要。
给每个格子赋值 count，然后 count++，表示往右填值。

(2) 右边：从上到下

// j 此刻已经停在 (n-offset) 这个列上了
// i从 startx 一直走到 n-offset
for (; i < n - offset; i++) {
    res[i][j] = count++;
}

当上边走完后，横坐标 i 还是等于 startx，列 j 已经跑到最右的地方了 (j == n-offset)。
现在我们要沿着最右边那一列，往下走。

(3) 下边：从右到左

// i 此刻停在 (n-offset) 这个行
// 让 j 从 (n-offset) 一直递减到 starty
for (; j > starty; j--) {
    res[i][j] = count++;
}

右边走完，意味着我们来到了最右下角的位置 (i, j) = (n-offset, n-offset)。
现在要从这个右下角开始，往左走（下边的一行）。
往左走时，j--，直到走到 starty + 1（因为循环是 j > starty ）。

4) 左边：从下到上

// j 此刻已经停在 starty
// i从 (n-offset) 递减到 startx
for (; i > startx; i--) {
    res[i][j] = count++;
}

下边走完后，我们已经到达 (n-offset, starty) 这个左下角坐标。
现在要往上走，i--，直到 i > startx。

注意：

为什么每个 for 循环条件都是类似 j < n-offset、j > starty 而不是 <= 之类？因为我们要避免重复填充同一个格子，也要考虑索引越界。
具体比较细节的界限，可以自己画个图，比如 3x3、4x4，跑一遍，就比较清楚了。

每圈结束后的处理

startx++, starty++：表示下一圈的起始位置往内收缩一格。
offset++: 表示右下边界也往内收缩一格。
这样就能进入下一圈(更里层的螺旋)，继续重复类似的四段循环

处理奇数时的中间点

如果 n 是奇数，比如 3, 5, 7……那在完成所有“外层圈”之后，正中心还会剩一个没有被填的格子。

比如 n=3 时，最外圈其实就把 8 个格子填完了，中间(1,1)那个格子就剩下，需要单独填。
这就是为什么最后有个判断

总结

最外层一圈要做四件事：上->右->下->左依次填数。
填完一圈后，把起点坐标“往里挪”，把“右/下边界”也往里收，进入下一圈。
当圈数转完，如果是奇数维度，就在中间补一下最后一个元素。

最核心的就是这个流程：

上边 (从左到右) → 右边 (从上到下) → 下边 (从右到左) → 左边 (从下到上)

然后不断往里缩，就可以把 n×n 的二维数组按螺旋方式填满啦。

整体C++代码如下：

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n, 0));
        int stx = 0, sty = 0;
        int cnt = 1, loop = n / 2;
        int off = 1;
        int i, j;
        while(loop --){
            i = stx, j = sty;
            for(j; j < n - off; j ++) res[i][j] = cnt ++;
            for(i; i < n - off; i ++) res[i][j] = cnt ++;
            for(; j > stx; j --) res[i][j] = cnt ++;
            for(; i > sty; i --) res[i][j] = cnt ++;
            stx ++, sty ++;
            off += 1;
        }
        if (n % 2) res[n / 2][n / 2] = cnt;
    return res;
    }
};

时间复杂度 O(n^2): 模拟遍历二维矩阵的时间
空间复杂度 O(1)

#类似题目

58. 区间和

题目链接(opens new window)

题目描述

给定一个整数数组 Array，请计算该数组在每个指定区间内元素的总和。

输入描述

第一行输入为整数数组 Array 的长度 n，接下来 n 行，每行一个整数，表示数组的元素。随后的输入为需要计算总和的区间，直至文件结束。

输出描述

输出每个指定区间内元素的总和。

输入示例

输出示例

3
9

数据范围：

0 < n <= 100000

思路

本题我们来讲解数组上常用的解题技巧：前缀和

首先来看本题，我们最直观的想法是什么？

那就是给一个区间，然后把这个区间的和都累加一遍不就得了，是一道简单不能再简单的题目。

代码如下：

#include <iostream>
#include <vector>
using namespace std;
int main() {
    int n, a, b;
    cin >> n;
    vector<int> vec(n);
    for (int i = 0; i < n; i++) cin >> vec[i];
    while (cin >> a >> b) {
        int sum = 0;
        // 累加区间 a 到 b 的和
        for (int i = a; i <= b; i++) sum += vec[i];
        cout << sum << endl;
    }
}

代码一提交，发现超时了.....

我在制作本题的时候，特别制作了大数据量查询，卡的就是这种暴力解法。

来举一个极端的例子，如果我查询m次，每次查询的范围都是从0 到 n - 1

那么该算法的时间复杂度是 O(n * m) m 是查询的次数

如果查询次数非常大的话，这个时间复杂度也是非常大的。

接下来我们来引入前缀和，看看前缀和如何解决这个问题。

前缀和的思想是重复利用计算过的子数组之和，从而降低区间查询需要累加计算的次数。

前缀和在涉及计算区间和的问题时非常有用！

前缀和的思路其实很简单，我给大家举个例子很容易就懂了。

例如，我们要统计 vec[i] 这个数组上的区间和。

我们先做累加，即 p[i] 表示下标 0 到 i 的 vec[i] 累加之和。

如图：

如果，我们想统计，在vec数组上下标 2 到下标 5 之间的累加和，那是不是就用 p[5] - p[1] 就可以了。

为什么呢？

p[1] = vec[0] + vec[1];

p[5] = vec[0] + vec[1] + vec[2] + vec[3] + vec[4] + vec[5];

p[5] - p[1] = vec[2] + vec[3] + vec[4] + vec[5];

这不就是我们要求的下标 2 到下标 5 之间的累加和吗。

如图所示：

p[5] - p[1] 就是红色部分的区间和。

而 p 数组是我们之前就计算好的累加和，所以后面每次求区间和的之后我们只需要 O(1) 的操作。

特别注意：在使用前缀和求解的时候，要特别注意求解区间。

如上图，如果我们要求区间下标 [2, 5] 的区间和，那么应该是 p[5] - p[1]，而不是 p[5] - p[2]。

很多录友在使用前缀和的时候，分不清前缀和的区间，建议画一画图，模拟一下思路会更清晰。

本题C++代码如下：

#include <iostream>
#include <vector>
using namespace std;
int main() {
    int n, a, b;
    cin >> n;
    vector<int> vec(n);
    vector<int> p(n);
    int presum = 0;
    for (int i = 0; i < n; i++) {
        cin >> vec[i];
        presum += vec[i];
        p[i] = presum;
    }

    while (cin >> a >> b) {
        int sum;
        if (a == 0) sum = p[b];
        else sum = p[b] - p[a - 1];
        cout << sum << endl;
    }
}

C++ 代码面对大量数据读取输出操作，最好用scanf 和 printf，耗时会小很多：

#include <iostream>
#include <vector>
using namespace std;
int main() {
    int n, a, b;
    cin >> n;
    vector<int> vec(n);
    vector<int> p(n);
    int presum = 0;
    for (int i = 0; i < n; i++) {
        scanf("%d", &vec[i]);
        presum += vec[i];
        p[i] = presum;
    }

    while (~scanf("%d%d", &a, &b)) {
        int sum;
        if (a == 0) sum = p[b];
        else sum = p[b] - p[a - 1];
        printf("%d\n", sum);
    }
}

44. 开发商购买土地

题目链接(opens new window)

【题目描述】

在一个城市区域内，被划分成了n * m个连续的区块，每个区块都拥有不同的权值，代表着其土地价值。目前，有两家开发公司，A 公司和 B 公司，希望购买这个城市区域的土地。

现在，需要将这个城市区域的所有区块分配给 A 公司和 B 公司。

然而，由于城市规划的限制，只允许将区域按横向或纵向划分成两个子区域，而且每个子区域都必须包含一个或多个区块。

为了确保公平竞争，你需要找到一种分配方式，使得 A 公司和 B 公司各自的子区域内的土地总价值之差最小。

注意：区块不可再分。

【输入描述】

第一行输入两个正整数，代表 n 和 m。

接下来的 n 行，每行输出 m 个正整数。

输出描述

请输出一个整数，代表两个子区域内土地总价值之间的最小差距。

【输入示例】

3 3 1 2 3 2 1 3 1 2 3

【输出示例】

【提示信息】

如果将区域按照如下方式划分：

1 2 | 3 2 1 | 3 1 2 | 3

两个子区域内土地总价值之间的最小差距可以达到 0。

【数据范围】：

1 <= n, m <= 100；
n 和 m 不同时为 1。

#思路

看到本题，大家如果想暴力求解，应该是 n^3 的时间复杂度，

一个 for 枚举分割线，嵌套两个for 去累加区间里的和。

如果本题要求任何两个行（或者列）之间的数值总和，大家在0058.区间和的基础上应该知道怎么求。

就是前缀和的思路，先统计好，前n行的和 q[n]，如果要求矩阵 a行到 b行之间的总和，那么就 q[b] - q[a - 1]就好。

至于为什么是 a - 1，大家去看 0058.区间和的分析，使用前缀和要注意区间左右边的开闭情况。

本题也可以使用前缀和的思路来求解，先将行方向，和列方向的和求出来，这样可以方便知道划分的两个区间的和。

#include <iostream>
#include <vector>
#include <climits>

using namespace std;
int main () {
    int n, m;
    cin >> n >> m;
    int sum = 0;
    vector<vector<int>> vec(n, vector<int>(m, 0)) ;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> vec[i][j];
            sum += vec[i][j];
        }
    }
    // 统计横向
    vector<int> horizontal(n, 0);
    for (int i = 0; i < n; i++) {
        for (int j = 0 ; j < m; j++) {
            horizontal[i] += vec[i][j];
        }
    }
    // 统计纵向
    vector<int> vertical(m , 0);
    for (int j = 0; j < m; j++) {
        for (int i = 0 ; i < n; i++) {
            vertical[j] += vec[i][j];
        }
    }
    int result = INT_MAX;
    int horizontalCut = 0;
    for (int i = 0 ; i < n; i++) {
        horizontalCut += horizontal[i];
        result = min(result, abs(sum - horizontalCut - horizontalCut));
    }
    int verticalCut = 0;
    for (int j = 0; j < m; j++) {
        verticalCut += vertical[j];
        result = min(result, abs(sum - verticalCut - verticalCut));
    }
    cout << result << endl;
}

时间复杂度： O(n^2)

其实本题可以在暴力求解的基础上，优化一下，就不用前缀和了，在行向遍历的时候，遇到行末尾就统一一下，在列向遍历的时候，遇到列末尾就统计一下。

时间复杂度也是 O(n^2)

代码如下：

#include <iostream>
#include <vector>
#include <climits>

using namespace std;
int main () {
    int n, m;
    cin >> n >> m;
    int sum = 0;
    vector<vector<int>> vec(n, vector<int>(m, 0)) ;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> vec[i][j];
            sum += vec[i][j];
        }
    }

    int result = INT_MAX;
    int count = 0; // 统计遍历过的行
    for (int i = 0; i < n; i++) {
        for (int j = 0 ; j < m; j++) {
            count += vec[i][j];
            // 遍历到行末尾时候开始统计
            if (j == m - 1) result = min (result, abs(sum - count - count));

        }
    }

    count = 0; // 统计遍历过的列
    for (int j = 0; j < m; j++) {
        for (int i = 0 ; i < n; i++) {
            count += vec[i][j];
            // 遍历到列末尾的时候开始统计
            if (i == n - 1) result = min (result, abs(sum - count - count));
        }
    }
    cout << result << endl;
}