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

977.有序数组的平方

要点：有负数，但数组有序，直接原地算平方，大小会是一个峰-谷-峰的形状，所以找大小的时候从大的开始找起

方法：

新建结果数组result，

用于给结果数组插值的索引k，

用在原数组上的头尾双指针i和j，

两指针索引处的数字比较平方的大小，

大的那个平方后从后往前存入新数组，

然后指针向中间方向移动一位，

两指针碰撞后停止循环。

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

209.长度最小的子数组

要点：一个正整数数组，一个target，在数组中取一块连续的数据，这块数据里数值相加大于等于target，返回连续数据的最小长度，否则返回0

方法： 

滑动窗口的左右边界指针都是从0开始

取一个变量记录每次移动指针后窗口的长度，

取一个变量记录窗口长度改变后最小窗口长度

移动右边界指针，直到符合target要求

再移动左边界指针，直到刚好不能满足target要求

每次移动任意指针且满足target，都要比较窗口长度

直至右指针到底，左指针也不再需要移动，即得到结果

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

59.螺旋矩阵II

要点：要返回一个n*n的二维数组，一圈一圈转进去，手画一下过程即可发现规律

方法：

正方形4条边，一圈为一个循环，每次循环分别填充4条边的数据

所以分给4条边的数据量大小要一致，不然边界条件很难处理

用变量确定每次循环的起始点（对角线）（startx, starty）

每条边长n-startx-循环第几圈（offset）

然后就是固定i填充j，固定j填充i的套路，去填满nums[i][j]

最后判断n的奇偶，决定最后中心的值

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> result(n, vector<int>(n, 0));
        int startx = 0, starty = 0;
        int loop = n / 2;
        int count = 1;
        int offset = 1;
        int i, j;
        while (loop--) {
            i = startx;
            j = starty;
            for (j; j < n - offset; j++) {
                result[i][j] = count++;
            }
            for (i; i < n - offset; i++) {
                result[i][j] = count++;
            }
            for (j; j > starty; j--) {
                result[i][j] = count++;
            }
            for (i; i > startx; i--) {
                result[i][j] = count++;
            }
            startx++;
            starty++;
            offset++;
        }
        if (n % 2 == 1) {
            result[n / 2][n / 2] = count;
        }
        return result;
    }
};