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

977.有序数组的平方

题目链接：977. 有序数组的平方，难度：简单

【实现代码】

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> result(nums);
        int k = nums.size();
        int i = 0;
        int j = nums.size() - 1;
        while (k--) {
            if (nums[i] * nums[i] < nums[j] * nums[j]) {
                result[k] = nums[j] * nums[j];
                j--;
            } else {
                result[k] = nums[i] * nums[i];
                i++;
            }
        }
        return result;
    }
};

【解题思路】

1. 输入的数组是一个降序的数组，那么最大值应在两端出现
2. 使用双指针，一个从左往右，一个从右往左，寻找两端的最大值
3. 将找到的最大值存入新数组的相对右端，并移动对应的指针
4. 当新数组存满时，结束循环，因为两个数组的个数相同，所以原数组也计算完成。

【总结】

【第一思路】第一思路还是暴力求解，计算平方后进行排序。
【存在的问题】昨天刚学完双指针的用法，今天不能想到使用双指针，知识掌握的太古板了！
【收获】学习使用双指针的新的场景，对于涉及到数组的第一想法是暴力求解时，考虑使用双指针。

209. 长度最小的子数组

题目链接：209. 长度最小的子数组，难度：中等

【实现代码】

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int i = 0;
        int j = 0;
        int result = nums.size();
        int subArraySize = 0;
        int sum = 0;
        while (i < nums.size()) {
            sum += nums[i];
            if (sum >= target) {                
                while (sum >= target) {
                    subArraySize = i - j + 1;
                    result = result < subArraySize ? result : subArraySize;
                    sum -= nums[j++];
                }
            }
            i++;
        }
        if (subArraySize == 0) {
            return 0;
        }
        return result;
    }
};

【解题思路】

1. 使用滑动窗口，当窗口内值的和小于target时，fastIndex（对应代码里的 i ）向右移动
2. 当窗口内值的和大于等于target时，记录此时的最小窗口长度，slowIndex（对应代码里的 j ）向右移动，重复这个过程直到窗口内值的和小于target
3. 当fastIndex到达数组末尾时，结束循环
4. 当字串subArraySize的值没有变化时（或者其他变量），说明数组的总和也小于target，返回0

【总结】

【第一思路】分情况讨论，数组的单个值大于等于target时，返回1；数组的总和小于target，返回0；再分别两个求和、三个求和、…太过复杂，而且不易实现
【存在的问题】

1. 当窗口滑动时，忘记更新最小字串的值
2. 依然没有使用合适算法的想法，想得太过于复杂

【收获】掌握了滑动窗口的使用，当涉及到数组的子数组时要想到使用滑动窗口。

59. 螺旋矩阵 II

题目链接：59. 螺旋矩阵 II，难度：中等

【实现代码】

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        int i = 0; //横向的数组下标
        int j = 0; //纵向的数组下标
        int k = 0; //圈数
        int s = 0; //步骤记录，即1、2、...、n^2
        vector<vector<int>> v(n, vector<int>(n, 0));
        while (k < n - 1) {
            for (; j < n - 1 - k; j++) { //从左向右填
                v[i][j] = ++s;
            }
            
            for (; i < n - 1 - k; i++) { //从上向下填
                v[i][j] = ++s;
            }

            for (; j > 0 + k; j--) { //从右向左填
                v[i][j] = ++s;
            }

            for (; i > 0 + k; i--) { //从下向上填
                v[i][j] = ++s;
            }
            i++;
            j++;
            k++;
        }
        if (n % 2 != 0) {
            v[n / 2][n / 2] = n * n;
        }
        return v;
    }
};

【总结】

【第一想法】想要使用一维数组进行规律求解，但是失败了。看了一部分讲解时发现是硬编码实现，又大概扫一眼看到了左闭右开，就自己实现了这个代码。
【存在的问题】

1. vector的嵌套初始化没有掌握；
2. 没有考虑到奇数情况时中心点的赋值。

【收获】

1. 掌握了vector的嵌套初始化；
2. 熟悉了类似题目的解决的方法。