代码随想录算法训练营第二天 （写！）| 209.长度最小的子数组、 59.螺旋矩阵II

LeetCode 209 长度最小的子数组

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

思路：

初看这题，感觉不难，题目就是要求我们找到数组中的几个数，要求它们的和加起来超过目标值target，一个要求就是要求个数尽可能的少。

我的第一想法就是排序，然后从大到小将数组中的数加起来，直到它们的和超过目标值，那么返回这几个数的个数，我们可以使用循环，使用一个计数器count，每做一次加和，count++（但是我实际写的时候将排序从大到小排序，这样就可以少用一个变量了）。如果数组中的全部数加起来都小于目标值，那么就意味着不存在这样的子数组，返回0。

那么，上vs

int minSubArrayLen(int target, int nums[],int n) {

    //首先，默写一下冒泡排序，这次希望从大到小排序
    int temp;
    for (int i = 0; i < n-1; i++) {
        for (int j = i; j < n - i - 1; j++) {
            if (nums[j] < nums[j + 1]) {
                temp = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = temp;
            }
        }
    }
        int sum = 0;
       
        for (int i = 0; i < n;) {
            sum += nums[i];
            if (sum >= target) {
                return i + 1;
            }
            else
                i++;

        }
       
        return 0;

}

思路明确了，那我们稍加修改一下看看能不能过。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int n = nums.size();
        // 首先，默写一下冒泡排序，这次希望从大到小排序
        int temp;
        for (int i = 0; i < n - 1; i++) {
            for (int j = i; j < n - i - 1; j++) {
                if (nums[j] < nums[j + 1]) {
                    temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }

        int sum = 0;

        for (int i = 0; i < n;) {
            sum += nums[i];
            if (sum >= target) {
                return i + 1;
            } else
                i++;
        }

        return 0;
    }
};

很好，三个例子过了两个，证明我们的初步思路大体上没什么问题。

既然出现了问题，那就解决问题，开始debug，找到问题。

此时，我发现，如果我将返回值i+1改为i，那么我就会通过第一个案例，第二个案例的输出值则少1。

非常尴尬的事情，我输出了排序之后的数组，发现原来是我的冒泡排序有问题。

于是乎，我们换成下浮的写法：

int temp;
for (int i = 0; i < n; i++) {
    for (int j = i+1; j < n ; j++) {
        if (nums[i] < nums[j]) {
            temp = nums[i];
            nums[i] = nums[j ];
            nums[j ] = temp;
        }
    }
}

修改一下LeetCode上对应的部分并提交

发现确实通过了16个案例，没有完全通过，说明我们的代码还有逻辑漏洞。

最大的逻辑漏洞就是我自己！

很好，子数组可以不连续但是不能改变顺序，原本以为反正是写个函数，返回的又不是子数列只是个数。

推翻重来！

那么既然不能排序，那么就按顺序找呗，做还是能做的，昨天刚学的双指针用起来！

设想：

有两个指针，一个代表子序列的开头，一个代表子序列的末尾，当子序列的数的和加起来超过目标值，那么这个子序列就结束，并且记录一下子序列中元素个数，遍历整个数组，比较每个符合条件的子序列的元素个数，返回最小的。（咱依旧默认它找不着，返回0）。

好了，看讲解去了！

---

LeetCode 59 螺旋矩阵II

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

示例 1：

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]

示例 2：

输入：n = 1
输出：[[1]]

思路：（我不会）

看到题目一脸懵，唯独能想到通过模拟顺时针画矩阵的过程来生成一个包含 1 到 n平方的所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

首先，初始化一个 n x n 的二维数组 res，将所有元素设置为 0。

定义四个变量 startx, starty, loop, mid，分别表示每循环一个圈的起始位置、每个圈循环的次数、矩阵中间的位置和计数器 count。

设置初始值：startx = 0, starty = 0, loop = n / 2, mid = n / 2, count = 1。

使用 while 循环，每次循环模拟填充一圈的元素。在循环内部，分别填充上行、右列、下行和左列的元素。

每填充完一圈后，更新起始位置和计数器，继续填充下一圈。

如果 n 为奇数，需要单独给矩阵最中间的位置赋值。

返回填充好的二维数组 res。

这个思路的核心是坚持循环不变量原则，即在每一圈的填充过程中，都遵循相同的规则（如左闭右开）。同时，通过控制每一条边遍历的长度（offset），可以确保每一圈的元素都能正确填充。

整理了一下大佬的思路，听的不是很懂，那就抄一遍吧。看看能理解多少。

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; j < n - offset; j++) {
                res[i][j] = count++;
            }
            // 模拟填充右列从上到下(左闭右开)
            for (i; 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;
    }
};

---

总结：好难！