代码随想录算法训练营第二天|Leetcode977 有序数组的平方 、Leetcode209 长度最小的子数组、Leetcode59 螺旋矩阵II

● Leetcode977 有序数组的平方

题目链接：Leetcode977 有序数组的平方
视频讲解：代码随想录|有序数组的平方
题目描述：给你一个按 非递减顺序 排序的整数数组 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]

● 解题思路

思路：
暴力求解： 对于本题的数组元素包含正数、负数以及0，所以无法单纯求每个元素的平方直接返回。最简单的办法就是对每个元素直接求平方之后，再对返回数组调用sort()方法进行排序就能得到答案。因为整个算法的时间复杂度取为sort()时间复杂度O（nlogn） 加上遍历数组元素取平方的时间复杂度O(n)，即O(n + nlogn)，因此其时间复杂度可以为O（nlogn）

时间复杂度：O（nlogn） 空间复杂度：O（1）

双指针求解： 对于原数组而言，每个元素平方后的最大值一定在最左或者最右，并不断向中间靠拢。因此，只需要比较两端数组元素平方后的大小之后，放入同原数组大小相同的新数组中。

需要注意的是，首尾指针的改变取决于是否选取了首元素或者尾元素，且对于for()循环终止的条件为i <= j， 避免遗漏最后一个元素。

时间复杂度：O（n） 空间复杂度：O（1）

● 代码实现

暴力求解

//暴力求解
class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        for(int i = 0; i < nums.size(); i++)
        {
            nums[i] *= nums[i];
        }
        sort(nums.begin(), nums.end());
        return nums;
    }
};

双指针求解

//双指针求解
class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> ans(nums.size(), 0);
        int k = nums.size() - 1;
        for(int i = 0, j = nums.size() - 1; i <= j;)
        {
            if(nums[i] * nums[i] > nums[j] * nums[j])
            {
                ans[k--] = nums[i] * nums[i];
                i++;
            }
            else
            {
                ans[k--] = nums[j] * nums[j];
                j--;
            }
        }
        return ans;
    }
};

● 本题收获

相较于暴力求解的方法，灵活使用双指针对问题进行求解可以降低解决问题的时间复杂度，提高算法的效率。

●Leetcode209 长度最小的子数组

题目链接：Leetcode209 长度最小的子数组
视频讲解：[代码随想录|长度最小的子数组|滑动窗口](https://www.bilibili.com/video/BV1QB4y1D7ep/?vd_source=ff2ef2c70aa83476c32493f33a06b16c)
题目描述：给定一个含有 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

● 解题思路

思路：
暴力求解： 遍历数组元素所有可能的区间，对比sum和target的大小，之后比较满足sum >= target的区间大小，选择最小的结果。

但对于Leedcode更新的测试用例，结果会显示超出时间限制，毕竟暴力解法列举了所有可能性，效率十分低。

时间复杂度：O（n^2） 空间复杂度：O（1）

滑动窗口

滑动窗口是数组/字符串问题中常用的抽象概念。不断调节数组/字符串子序列的起始位置和终止位置，寻找满足条件的区间。
滑动窗口这类问题一般需要用到双指针来进行求解，另外一类比较特殊则是需要用到特定的数据结构，像是 sorted_map、set。

滑动窗口解决的问题大致分为两类：
1、给出两个长度不同的字符串，求长串的最短子串，该子串必须覆盖短子串的所有字符。
2、给出一个字符串或者数组，求所有字符都只出现一次的最长子串、求含有少于 k 个不同字符的最长子串。

滑动窗口求解：
对于暴力求解中for循环中的i，就是遍历所有滑动窗口的起始位置，而j则是遍历滑动窗口的终止位置，通过两层循环达到遍历滑动窗口的目的。

而滑动窗口则是使用一个for循环完成对滑动窗口的遍历。正因为只使用一个for循环，我们需要考虑遍历的是滑动窗口的终止位置还是起始位置？如果我们此时的for循环遍历的滑动窗口的起始位置，仍然需要我们不断遍历其终止位置，效果就会和暴力求解一样。
我们需要考虑的是，应该先寻找到满足条件的区间是从起始位置到哪，因此对于for循环我们需要遍历的就是滑动窗口的终止位置。当找到满足条件的区间之后，我们在变更滑动窗口寻找最小结果。

时间复杂度：O（n） 空间复杂度：O（1）

● 代码实现

暴力求解

//暴力求解
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int result = INT32_MAX; // 最终的结果
        int sublength = 0; // 子序列长度
        for(int i = 0; i < nums.size(); i++)
        {
            int sum = 0;
            for(int j = i; j < nums.size(); j++)
            {
                sum += nums[j]; 
                if(sum >= target) //当子序列和满足 >=target时更新result
                {
                    sublength = j - i + 1; //获取最新子序列长度
                    result = result < sublength ? result : sublength; //对比更新result
                    break;
                }
            }
        }
        // 如果result没有被赋值即没有满足条件的子序列，就返回0
        return result == INT32_MAX ? 0 : result;
    }
};

//滑动窗口
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int result = INT32_MAX; 
        int sublength = 0; // 滑动窗口长度
        int sum = 0; // 滑动窗口内元素和
        int i = 0; // 滑动窗口起始位置
        for(int j = 0; j < nums.size(); j++) // j为滑动窗口终止位置
        {
            sum += nums[j];
            while(sum >= target) 
            // 滑动窗口终止位置不变的情况下，改变起始位置寻找条件的最小的滑动窗口区间
            {
                sublength = j - i + 1; // 子序列/滑动窗口长度
                result = min(sublength, result);
                sum -= nums[i++]; // 改变起始位置的同时改变滑动窗口内元素和，寻找满足条件的最小滑动窗口
            }
        }
        return result == INT32_MAX ? 0 : result;
    }
};

● 思考

通常看到for循环内嵌套一个while循环，我们会简单的将时间复杂度理解为O（n^2），但实际不然。
实际的时间复杂度主要是看每一个元素被操作的次数，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n 也就是O(n)

●Leetcode59 螺旋矩阵 II

题目链接：Leetcode59 螺旋矩阵 II
视频讲解：代码随想录|螺旋矩阵 II|循环不变量
题目描述：给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。
示例 1：

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

● 解题要点

当我们模拟循环填入数组元素时，需要明确在整个过程的循环不变量是什么，对于我们的数组而言到底是左闭右闭还是左闭右开。

假如我们的循环不变量为左闭右闭，完成从左向右循环之后将会应该到从上向下循环的不变量规则。

而当我们的循环不变量规则为左闭右开，我们就会发现在每一层循环都遵守相同的不变量规则。

● 解题思路

思路：
在整个过程中坚持循环不变量规则，模拟顺时针填充矩阵的过程：
·填充上行从左到右
·填充右列从上到下
·填充下行从右到左
·填充左列从下到上
在每一次循环中，我们都需要进行上述四个过程。
当n为奇数时，必然导致最后一次循环之后剩余中间一个位置没有赋值，此时再手动为其赋值即可。

时间复杂度：O（n^2） 空间复杂度：O（1）

● 代码实现

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n, 0));
        int start_x = 0, start_y = 0; // 定义每一圈循环的起始位置
        int loop = n / 2; // 循环的圈数
        int mid = n / 2; // 当n为基数时最中间无法参与循环的位置
        int offset = 1; // 控制每一圈循环的边界
        int count = 1; // 为每个位置赋值
        int i, j;
        while(loop--)
        {
            //每一个loop分别需要四个for循环填入元素
            i = start_x, j = start_y;

            //模拟从左向右填入元素
            for(j = start_y; j < n - offset; j++)
            {
                res[start_x][j] = count++;
            }

            //模拟从上向下填入元素
            for(i = start_x; i < n - offset; i++)
            {
                res[i][j] = count++;
            }

            //模拟从右向左填入元素
            for(; j > start_y; j--)
            {
                res[i][j] = count++;
            }

            //模拟从下向上填入元素
            for(; i > start_x; i--)
            {
                res[i][j] = count++;
            }

            //下一循环的start_x, start_y, offset都需要进行++操作
            start_x++;
            start_y++;
            offset++;
        }

        //当n为奇数时，剩余最中间位置无法参与循环，单独赋值
        if(n % 2 == 1)
        {
            res[mid][mid] = count;
        }
        return res;
    }
};