Day02｜数组part02: 977.有序数组的平方，209.长度最小的子数组，59.螺旋矩阵II-CSDN博客

本文链接：https://blog.csdn.net/weixin_43303286/article/details/131700482

Day02｜数组part02: 977.有序数组的平方，209.长度最小的子数组，59.螺旋矩阵II

今天的题量有点多，但基本也是看了就有思路，其中59螺旋矩阵是我的一生之敌，估计下次碰到还是不会一次性ac。。。即使有思路但就是很难完全正确。。。

977. 有序数组的平方

题目链接：https://leetcode.cn/problems/squares-of-a-sorted-array/

视频链接： https://www.bilibili.com/video/BV1QB4y1D7ep

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

这题一刷的时候想到的方法就是暴力，对数组进行绝对值的排序，然后再分别平方，实际上这样复杂度就成了O(nlogn)了，不符合题目要求，二刷就立马想到了用双指针，因为左右两头的绝对值肯定是较大的，因此选择一个左右指针比较左右两端的大小就可以，然后将结果逆序输出：

```cpp
class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        //有序数组，靠近两头的数的绝对值越大，平方越大；
        int left = 0, right = nums.size() - 1;
        int k = nums.size() - 1;//控制res的输出
        vector<int> res(nums.size());//需要倒序输出
        while (left <= right){
            if(nums[left] * nums[left] > nums[right] * nums[right]){
                res[k--] = nums[left] * nums[left];
                left++;
            }else{
                res[k--] = nums[right] * nums[right];
                right--;
            }
        }
        return res;
    }
};
```

没什么难度，但总觉得代码写的不够简洁漂亮，标准题解:

```cpp
class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        int k = A.size() - 1;
        vector<int> result(A.size(), 0);
        for (int i = 0, j = A.size() - 1; i <= j;) { // 注意这里要i <= j，因为最后要处理两个元素
            if (A[i] * A[i] < A[j] * A[j])  {
                result[k--] = A[j] * A[j];
                j--;
            }
            else {
                result[k--] = A[i] * A[i];
                i++;
            }
        }
        return result;
    }
};
```

这题没什么好说的，双指针方法的应用。

209.长度最小的子数组

题目链接：https://leetcode.cn/problems/minimum-size-subarray-sum/

视频链接：https://www.bilibili.com/video/BV1tZ4y1q7XE

```cpp
给定一个含有 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
```

关键在于如何使用O(n)的时间复杂度解决问题。这里使用的是滑动窗口，订左右边界。

值得注意的是这个过程中的变量和不变量是什么，也就是顺序遍历的应该是滑动窗口的左还是右，这里应该选右，因为如果是左，那就跟暴力解法没什么区别了。这题改了几次才AC，还是不太熟练，下面是我的代码，注意点在注释里：

```cpp
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int min = INT32_MAX;//先定一个决定不可能被超过的数
        int i = 0;
        int sum = 0;
        int subLength = 0;//滑动窗口大小
        for(int j = 0; j < nums.size(); j++) {//右端为for循环中的变量
            /**********************/
            sum += nums[j];
            while (sum >= target) {//这里是大于等于，而且使用的是while循环，因为符合条件时窗口不一定只滑动一次
                subLength = (j - i + 1); // 取子序列的长度
                min = min < subLength ? min : subLength;
                sum -= nums[i++]; // 窗口“滑动”，前一位出列
            }
            /*************************/

        }
        if(min == INT32_MAX){
            return 0;
        }
        return min;
    }
};
```

/*****/中的内容可概括为：

- 右边界拓展
- 检验条件（while）
- 左边界出列。

之后又去做了相关题目。

904. 水果成篮

你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 `fruits` 表示，其中 `fruits[i]` 是第 `i` 棵树上的水果 **种类** 。

你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：


- 你只有 **两个** 篮子，并且每个篮子只能装 **单一类型** 的水果。每个篮子能够装的水果总量没有限制。
- 你可以选择任意一棵树开始采摘，你必须从 **每棵** 树（包括开始采摘的树）上 **恰好摘一个水果** 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
- 一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。

给你一个整数数组 `fruits` ，返回你可以收集的水果的 **最大** 数目。

**示例 1：**

**输入：**fruits = [***1,2,1***]

**输出：**3

**解释：**可以采摘全部 3 棵树。

**示例 2：**

**输入：**fruits = [0,***1,2,2***]

**输出：**3

**解释：**可以采摘 [1,2,2] 这三棵树。

如果从第一棵树开始采摘，则只能采摘 [0,1] 这两棵树。

**示例 3：**

**输入：**fruits = [1,***2,3,2,2***]

**输出：**4

**解释：**可以采摘 [2,3,2,2] 这四棵树。

如果从第一棵树开始采摘，则只能采摘 [1,2] 这两棵树。

这题也是滑动窗口的题目，理解一下题目意思，也就是说限制两个种类，求最长的子序列的长度，子序列中只能有两个数，相同的数越多越好。

这题一开始我就想到了用hash表存次数，滑动的时候对应的value-1，为0时直接删掉key，这里滑动窗口的限制是里面只能出现两个数，也就是hash表的大小<=2：

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        int i = 0;
        int res = 0;
        unordered_map<int,int> table;//存放种类i的水果出现的次数
        for(int j = 0; j < fruits.size(); j++){
            table[fruits[j]]++;//右边界拓展
            while(table.size() > 2){//检测条件
                auto it = table.find(fruits[i]);
                it->second--;//左边界滑动
                if(it->second == 0){
                    table.erase(it);
                }
                i++;
            }
            res = max(res,j - i + 1);//j - i + 1为滑动窗口大小
        }
        return res;
    }
};

可以看到这个也是三部曲。右边拓展、检测条件、左边滑动。

59.螺旋矩阵II

这个我放弃了，感觉ac太难了233333。之前有点想当然了，认为转过四次就没了，实际上n一大是不止转一圈的，比如4需要转两次：

因此也需要设置循环次数，这个对我的难点倒不是区间的开闭，而是要设的未知量实在是太多了，很难想全，先把代码放这里：

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n, 0)); // 使用vector定义一个二维数组
        int startx = 0, starty = 0; // 定义每循环一个圈的起始位置
        int loop = n / 2; // 每个圈循环几次，例如n为奇数3，那么loop = 1 只是循环一圈，矩阵中间的值需要单独处理
        int mid = n / 2; // 矩阵中间的位置，例如：n为3， 中间的位置就是(1，1)，n为5，中间位置为(2, 2)
        int count = 1; // 用来给矩阵中每一个空格赋值
        int offset = 1; // 需要控制每一条边遍历的长度，每次循环右边界收缩一位
        int i,j;
        while (loop --) {
            i = startx;
            j = starty;
            // 下面开始的四个for就是模拟转了一圈
            // 模拟填充上行从左到右(左闭右开)
            for (j = starty; j < n - offset; j++) {
                res[startx][j] = count++;
            }
            // 模拟填充右列从上到下(左闭右开)
            for (i = startx; i < n - offset; i++) {
                res[i][j] = count++;
            }
            // 模拟填充下行从右到左(左闭右开)
            for (; j > starty; j--) {
                res[i][j] = count++;
            }
            // 模拟填充左列从下到上(左闭右开)
            for (; i > startx; i--) {
                res[i][j] = count++;
            }

            // 第二圈开始的时候，起始位置要各自加1， 例如：第一圈起始位置是(0, 0)，第二圈起始位置是(1, 1)
            startx++;
            starty++;

            // offset 控制每一圈里每一条边遍历的长度
            offset += 1;
        }

        // 如果n为奇数的话，需要单独给矩阵最中间的位置赋值
        if (n % 2) {
            res[mid][mid] = count;
        }
        return res;
    }
};