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

977. 有序数组的平方

题目：给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

第一遍自己做题思路：先得到数据平方后的数组，由于是非递减的，所以两头的值是最大的，两头往中间走数值会越来越小。所以用双指针从两头往中间逼近。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> result(nums.size(), 0);
        for (int i = 0; i < nums.size(); i++) {
            nums[i] = nums[i] * nums[i]; //可以简写为nums[i] *= nums[i];
        }
        int n = nums.size() - 1;
        int left = 0, right = n;
        while ( left <= right) { //特别注意，这里的条件包含等于，最后left和right指向同一个元素才结束。
            if (nums[left] > nums[right]) {
                result[n--] = nums[left++];
            }else {
                result[n--] = nums[right--];
            }
        }
        return result;
    }
};

做题时，在while后的判断条件出错，尤其注意有等号，因为最后left和right同时指向最小的元素才结束。

代码随想录文档中提供了暴力法和双指针法。

暴力法

直接使用sort(A.begin(), A.end())进行快速排序。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        for (int i = 0; i < A.size(); i++) {
            A[i] *= A[i];
        }
        sort(A.begin(), A.end()); // 快速排序
        return A;
    }
};

 双指针法

整体上和我的思路差不多，不过省略了第一步将数组的数据先平方的过程，更简洁一些。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        int k = A.size() - 1;
        vector<int> result(A.size(), 0);
        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;
    }
};

209.长度最小的子数组

题目：

给定一个含有 n 个正整数的数组和一个正整数 target 。找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组[numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

思路：这道题自己没想出来，本来想用双层for循环，但子数组有可能包含多个元素，如果写出来就太复杂，然后就不知道应该怎么做了。

答案用了暴力解法和滑动窗口。

暴力解法

答案中抓住问题的条件时取最短的子序列，所以引入了子序列的长度，用语句“result = result < subLength ? result : subLength;”找到符合条件的子序列。

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int result = INT32_MAX; // 最终的结果
        int sum = 0; // 子序列的数值之和
        int subLength = 0; // 子序列的长度
        for (int i = 0; i < nums.size(); i++) { // 设置子序列起点为i
            sum = 0;
            for (int j = i; j < nums.size(); j++) { // 设置子序列终止位置为j
                sum += nums[j];
                if (sum >= s) { // 一旦发现子序列和超过了s，更新result
                    subLength = j - i + 1; // 取子序列的长度
                    result = result < subLength ? result : subLength;
                    break; // 因为我们是找符合条件最短的子序列，所以一旦符合条件就break
                }
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result;
    }
};

滑动窗口

滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。滑动窗口也可以理解为双指针法的一种！只不过这种解法更像是一个窗口的移动，

在本题中实现滑动窗口，主要确定如下三点：

• 窗口内是什么？
• 如何移动窗口的起始位置？
• 如何移动窗口的结束位置？

滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)暴力解法降为O(n)。

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;
    }
};

参考了其他资料，发现了一个更滑动窗口的解法。窗口左边不通过for循环来控制，而是一旦sum大于target，就将窗口右移。

class Solution {
public:
int minSubArrayLen(int s, vector<int>& nums) {
    int minLen=INT_MAX, left=0, right=0, sum=0;
    while (right<nums.size()){
        sum+= nums[right++];
        while (sum>=s){
            sum-=nums[left++];
            minLen = min (minLen, right-left+1);
        }
    }
    return minLen==INT_MAX? 0:minLen;
  }
};

59.螺旋矩阵II

题目：

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

思路：本题就是按照旋转路径进行遍历，但是要注意边界条件。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> matrix(n, vector<int>(n));
        int x = 1;
        int left = 0, right = n - 1;
        int j = 0, i = 0;
        while (left < right){
            while (j < right){
                matrix[i][j++] = x++;
            }
            while (i < right){
                matrix[i++][j] = x++;
            }
            while (j > left){
                matrix[i][j--] = x++;
            }
            while (i > left){
                matrix[i--][j] = x++;
            }
            i++;
            j++;
            left++;
            right--;
        }
        if (left == right){
            matrix[i][j] = x;
        }
        return matrix;
    }
};

总结 

 今天的题目用基础的思路解决稍微复杂一些的问题，稍微上了一些难度，且对细节的把控能力要求更高。双指针法一定要深入理解，可以在很多时侯简化算法，例如滑动窗口（双指针的变体）就很巧妙。螺旋矩阵考察的时对边界条件的掌控能力，这种题最好动手画一画示意图，能更好的理解，快速的给出边界条件。