_2LeetCode代码随想录算法训练营第二天C++数组 | 977.有序数组的平方、209.长度最小的子数组、59.螺旋矩阵II

_2LeetCode代码随想录算法训练营第二天C++数组 | 977.有序数组的平方、209.长度最小的子数组、59.螺旋矩阵II

LeetCode 题目列表：

• 977.有序数组的平方
• 209.长度最小的子数组
• 59.螺旋矩阵II

977.有序数组的平方

代码随想录地址：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]

提示：

• 1 <= nums.length <= $10^4$
• -$10^4$ <= nums[i] <= $10^4$
• nums 已按 非递减顺序 排序

进阶：

• 请你设计时间复杂度为 O(n) 的算法解决本问题

题目所述数组含有负数。

双指针的思路

双指针的思路：

最大元素一定是在两边，考虑用两个指针逐步向中间合拢，得到一个由大到小的数组，在更新数组时也由大索引到小索引更新。

代码

/*
 * @lc app=leetcode.cn id=977 lang=cpp
 *
 * [977] 有序数组的平方
 */

// @lc code=start
class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> result(nums.size(), 0);//初始化结果数组
        int index = nums.size() - 1;//初始化更新数组的index
        for(int i = 0,j = nums.size() - 1; i <= j; )//双指针往中间夹击
        {
            int muti_i = nums[i]*nums[i];//此处是为了少算一次*法
            int muti_j = nums[j]*nums[j];//此处是为了少算有一次*法
            if(muti_i > muti_j)//如果i指向的元素的平方更大
            {
                result[index--] = muti_i;//更新结果数组和更新index
                i++;//更新i
            }
            else//如果i和j指向的元素的平方相等或j指向的元素的平方更大
            {
                result[index--] = muti_j;//更新结果数组和更新index
                j--;//更新j
            }
        }
        return result;
    }
};
// @lc code=end

犯的错误

将这一句
for(int i = 0,j = nums.size() - 1; i <= j; )//双指针往中间夹击
写成了
for(int i = 0, int j = nums.size() - 1; i <= j; )//双指针往中间夹击
属于是低级错误

209.长度最小的子数组

代码随想录地址：https://programmercarl.com/0209.%E9%95%BF%E5%BA%A6%E6%9C%80%E5%B0%8F%E7%9A%84%E5%AD%90%E6%95%B0%E7%BB%84.html

题目

给定一个含有 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 <= $10^9$
• 1 <= nums.length <= $10^5$
• 1 <= nums[i] <= $10^5$

进阶：

• 如果你已经实现 O(n) 时间复杂度的解法, 请尝试设计一个 O(n log(n)) 时间复杂度的解法。

暴力解法

使用两层嵌套for循环，第一层表示起始位置，第二层表示终止位置，遍历所有的情况，求得长度最小的子数组。

双指针的思路

滑动窗口的思想

只用一个for循环解决问题，那么for循环里面的索引是滑动窗口的起始位置还是终止位置呢？如果是起始位置，那么和暴力解法一样把所有的终止位置都遍历了一遍，所以是终止位置。

重点所在

那么如何决定起始位置呢？需要使用一个动态移动的策略确定。即当集合里面的所有元素和大于等于target时，就可以移动起始位置了。

代码

/*
 * @lc app=leetcode.cn id=209 lang=cpp
 *
 * [209] 长度最小的子数组
 */

// @lc code=start
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int result = INT32_MAX;//首先将结果赋值为超大的值
        int subLength = 0;//表示滑动窗口的大小
        int i = 0;//表示滑动窗口的起始位置
        int sum = 0;//记录滑动窗口元素和
        for(int j = 0;j < nums.size();j++)
        {
            sum += nums[j];//滑动窗口后移一位，就将新的滑动窗口的终止位置的元素加到sum中
            while(sum >= target)//当sum大于等于target时，就要更新起始位置了
            {
                subLength = j - i + 1;//求得当前滑动窗口的大小
                result = subLength < result ? subLength : result;//与result比较，如果比result更小则更新result为subLength；否则不更新result。
                sum -= nums[i++];//sum减掉滑动窗口起始位置的元素，更新i
            }
        }
        return result < INT32_MAX ? result : 0;
    }
};
// @lc code=end

时间复杂度

每个元素在滑动窗口进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n 也就是O(n)。

问题

在for循环中，为什么不使用if而使用while呢？

如果target = 100

可能存在这样的滑动窗口：[1, 1, 1, 1, 1, 100]

需要求得最小的result。

59.螺旋矩阵II

代码随想录地址：https://programmercarl.com/0059.%E8%9E%BA%E6%97%8B%E7%9F%A9%E9%98%B5II.html

题目

给你一个正整数 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 <= 20

错误思路

处理每条边的时候，规则不统一；导致需要处理很多边界条件，这样就很容易出错。

循环不变量

循环就是一圈一圈地处理，不变量就是每条边地处理规则一样。

采用左闭右开的规则：如上图所示，处理第一行时只处理1、2；处理第三列时只处理3、4；处理第三行时只处理5、6；处理第一列时只处理7、8；对于每一个循环皆如此，直到循环结束。

代码

/*
 * @lc app=leetcode.cn id=59 lang=cpp
 *
 * [59] 螺旋矩阵 II
 */

// @lc code=start
class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n, 0));//使用vector定义一个二维数组
        int startx = 0,starty = 0;//定义初始位置为(0,0)
        int loop = n / 2;//表示执行几个圈，n为偶数时可行，但是n为基数时会忘掉中心位置的元素，这个就可以在最后做一个判断
        int offset = 1;//执行一圈就将其加1，目的是计算边界
        int data = 1;//记录数值1->2->3...->n
        int i,j;//相当于是索引
        while(loop--)
        {
            i = startx, j = starty;
            //处理一个圈的上(左闭右开)
            for(; j < n - offset; j++)
                res[startx][j] = data++;
            //处理一个圈的右(左闭右开) 此时j == n - offset
            for(; i < n - offset; i++)
                res[i][j] = data++;
            //处理一个圈的下(左闭右开) 此时i == n - offset, j == n - offset
            for(; j > starty; j--)
                res[i][j] = data++;
            //处理一个圈的左(左闭右开)，此时i == n - offset, j == starty
            for(; i > startx; i--)
                res[i][j] = data++;
            
            //处理完一圈之后，要移动初始位置和offset
            startx++;
            starty++;
            offset++;
        }
        if(n % 2 == 1)//如果n是基数，则要添加以下中心位置的元素
        {
            int mid = n / 2;
            res[mid][mid] = data;
        }
        return res;
    }
};
// @lc code=end