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

977.有序数组的平方

力扣题目链接

文章讲解

一种直观的思想是暴力解法，将每个位置遍历然后平方后，再整体排序一次。时间复杂度O(n + nlog n)

另一种也可以用到双指针。注意题干条件：nums数组为非递减顺序

主打一个关键点：数组平方的最大值不是在最左边，就是在最右边，不可能在中间

其实很容易理解，平方最大嘛，相当于绝对值最大，要么就是负得最多，要么就是正得最多

怎么利用这个特点呢？双指针法

一个指针指向数组最左端，一个指针指向数组最右端，然后取出最大的平方项，放在结果里，然后看情况移动这两个指针，缩减平方后最大的元素可能出现的区间

代码如下

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int leftIndex = 0, rightIndex = nums.size() - 1;    //指向两端的指针
        vector<int> res(nums.size());
        int resIndex = nums.size() - 1;    //指向结果数组待填充的位置
        while (leftIndex <= rightIndex) {    //注意<=，因为是左闭右闭方式描述区间
            if (nums[leftIndex] * nums[leftIndex] <= nums[rightIndex] * nums[rightIndex])
            {
                res[resIndex] = nums[rightIndex] * nums[rightIndex];
                resIndex--;
                rightIndex--;
            } else {
                res[resIndex] = nums[leftIndex] * nums[leftIndex];
                resIndex--;
                leftIndex++;
            }
        }
        return res;
    }
};

有下面几个细节需要注意

• 初始化两个指针leftIndex为0，rightIndex为size - 1，能够看出我们描述nums中元素区间用的是左闭右闭方式[leftIndex, rightIndex]
• while条件和上一篇二分搜索同理，当平方后最大的元素可能出现的区间还有元素时，就要一直循环，故while (leftIndex <= rightIndex)，注意等于时也是有元素的，需要进循环。
• resIndex的作用：指向结果数组下一个需要被填充的位置

当然，这道题能够在上面代码上做如下简化，但是思路是一样的 

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        int k = A.size() - 1;    //指向结果数组下一个需要被填充的位置
        vector<int> result(A.size(), 0);
        //左指针i，右指针j
        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;
    }
};

可以看出这道题和Day1中多少有点儿技巧上的共性，二分搜索通过移动左右指针缩减待搜索元素可能出现的区间，本题通过左右指针缩减平方后最大元素可能出现的区间；移除元素中用指针指向新数组下一个需要更新（被填充）的位置，这里也用到了。所以关键还是那么几点：确定区间的描述方式、定循环条件、如何缩减区间、记得维护指针指向结果数组下一个需更新的位置

---

209.长度最小的子数组

力扣题目链接

文章讲解

直观想法：暴力法，两个for循环，第一个for循环遍历子序列的起始，第二个for循环遍历子序列的末尾，从而找到所有的子序列，然后对每个子序列都看看总和，算算长度，看是不是最小

显然，复杂度O(n^2)，很呆，不妥

想到使用滑动窗口法

滑动窗口法是什么：一图以蔽之

简单来说，就是维护两个指针，分别指向子序列的起始位置和终止位置，通过不断调节起始位置和终止位置，得到我们想要的结果

形象一点儿的描述方式 ：可以想象一下毛毛虫在爬行

毛毛虫的头部代表了子序列的终止位置，毛毛虫的尾部代表子序列的起始位置。毛毛虫身体盖住的范围就是这个“窗口”。可以从图看出：通过不断调节毛毛虫的头部位置和尾部位置来实现窗口的变化。

这道题中主要需要确定以下几点

1. 什么时候在右侧扩大窗口（毛毛虫头部向右伸）
2. 什么时候在左侧缩小窗口 （毛毛虫尾部向右缩）

这道题中，当窗口内元素和小于target的时候，在右侧扩大窗口，当窗口内元素和大于等于target的时候，在左侧缩小窗口

看代码如下

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
       int slow = 0, fast = 0;
       int sum = 0;
       int res = INT32_MAX;    //窗口最小长度
       int len = 0;
       while (fast < nums.size()) {
            sum += nums[fast++];
            len++;
            while (sum >= target) {
                res = res < len ? res : len;
                sum -= nums[slow++];
                len--; 
            }
       }
       return res == INT32_MAX ? 0 : res;
    }
};

slow是窗口左侧，fast为窗口右侧，[slow, fast]代表窗口元素。外层循环while中当窗口右侧没有到数组最右侧的时候，就可以一直向右扩大窗口（相当于毛毛虫头部没走到尽头）。扩大窗口需要做一系列操作来维护窗口内元素和以及窗口长度。

然后，当某个时刻，窗口内元素大于等于target了，表明此时窗口所覆盖序列为一个满足和>=target的序列，此时应将该窗口的长度与之前窗口最小长度比，看看此时这个序列的长度是不是更小，如果更小的话需要更新最小长度。接下来，需要在左侧缩减窗口大小，缩小窗口同样需要做一系列操作来维护窗口内元素和以及窗口长度。注意内层需要用while表示“不断缩减长度直到窗口内的元素和又重新小于target”

另一种写法

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int result = INT32_MAX;
        int sum = 0; // 滑动窗口数值之和
        int i = 0; // 滑动窗口起始位置
        int subLength = 0; // 滑动窗口的长度
        for (int j = 0; j < nums.size(); j++) {
            sum += nums[j];
            // 注意这里使用while，每次更新 i（起始位置），并不断比较子序列是否符合条件
            while (sum >= s) {
                subLength = (j - i + 1); // 取子序列的长度
                result = result < subLength ? result : subLength;
                sum -= nums[i++]; // 这里体现出滑动窗口的精髓之处，不断变更i（子序列的起始位置）
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result;
    }
};

注意这两种写法的共同点如下

• return需要考虑没有符合条件的子序列的情况，此时进不了内层while循环
• 外层循环都控制的窗口右侧扩大，内层循环才控制窗口左侧缩小 

这个很关键，因为看毛毛虫爬行的逻辑是“先不断伸长，再不断缩短” 

---

59.螺旋矩阵II

力扣题目链接

文章讲解

这道题不涉及算法，就是模拟过程。硬做 

主打一个考察写代码的水平

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        int x = 0, y = 0;   //初始位置(x, y)
        enum {right, down, left, up} direction = right;	//一开始设定方向往右
        vector<vector<int> > result(n, vector<int>(n, 0));  //生成一个n*n的全0矩阵
        for (int i = 1; i <= n * n; i++)	//i为每个位置待填充的元素，最多填充到n^2，因此循环到<=n*n 
        {
            result[x][y] = i;	//填充完成，接下来准备沿着既定方向去到下一个待填充的位置
            //既定方向向右
            if (direction == right)
            {
                if ((y + 1) < n && result[x][y + 1] == 0)	//如果还没有走到矩阵右侧尽头且右边一个位置还没被填充过，那么这次就往右走
                {
                    ++y;
                    continue;
                }
                else
                {	//沿这方向走到头了,再看看能不能向下走
                    direction = down;
                }
            }

            //既定方向向下
            if (direction == down)
            {
                if ((x + 1) < n && result[x + 1][y] == 0) //如果还没有走到矩阵下侧尽头且下边一个位置还没被填充过，那么这次就往下走
                {
                    ++x;
                    continue;
                }
                else
                {	//沿这个方向走到头了，再看看能不能向左走
                    direction = left;
                }
            }

            //既定方向向左
            if (direction == left)
            {
                if ((y - 1) >= 0 && result[x][y - 1] == 0)
                {
                    --y;
                    continue;
                }
                else
                {
                    direction = up;
                }
            }

            //既定方向向上
            if (direction == up)
            {
                if ((x - 1) >= 0 && result[x - 1][y] == 0)
                {
                    --x;
                    continue;
                }
                else
                {   //向上走不了了，那么不用看了，该往右走了，并走出一步（别忘了要实现选择方向并前进）
                    direction = right;
                    if ((y + 1) < n && result[x][y + 1] == 0)
                        y++;
                }
            }
        }
        return result;
    }
};

将整个过程模拟成：到了一个位置，填充数字，然后沿着既定方向前进，前进不了则选择另一个方向再试试能不能前进，能的话就前进。

选择方向需要分别看看能不能向右走，能不能向下走，能不能向左走，能不能向右走（顺时针）

注意：在通过索引访问数组的时候，判断越界一定要在访问前！（力扣很多错误就是因为这样导致的）即

if ((y + 1) < n && result[x][y + 1] == 0)

逻辑运算符左右两侧表达式顺序不能换 

位置用坐标(x, y)描述。这个坐标是以左上角为原点的

---

回顾总结

除了509是一道硬做题，其他主要还是靠通过维护双指针来维护区间的手法