LeetCode第2天｜977.有序数组的平方 209.长度最小的子数组 59.螺旋矩阵II

977.有序数组的平方

题目链接: https://leetcode.cn/problems/squares-of-a-sorted-array/
关键词：有序数组

解法一：双指针

最大的数只可能在容器两头，故用两个指针分别指向容器两端，将大的元素放在新数组的最末端

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> newnums(nums.size());
        int target = nums.size() - 1;
        int left = 0, right = nums.size() - 1;
        for(; left <= right;){	//注意此处写法
            if(pow(nums[left], 2) > pow(nums[right], 2)){
                newnums[target] = pow(nums[left], 2);
                left++;
            }else{
                newnums[target] = pow(nums[right], 2);
                right--;
            }
            target--;            
        }
    return newnums;
    }
};

解法二：暴力解

直接平方后再排序

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> newnums;
        for(int i : nums){
            newnums.push_back(i * i);   //注意vector插入元素的语法
        }
        sort(newnums.begin(), newnums.end());   //c++内置快排，默认升序排列
        return newnums;
    }
};

209.长度最小的子数组

题目链接: https://leetcode.cn/problems/minimum-size-subarray-sum/
关键词：连续最短的子数组

解法一：滑动窗口（双指针）

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int minSize = INT32_MAX;    //最小滑动窗口大小
        int Size = 0;   //当前滑动窗口大小
        int sum = 0;
        int i = 0;
        for(int j = 0; j < nums.size(); j++){
            sum += nums[j];
            while(sum >= target){
                Size = j - i + 1;
                minSize = minSize < Size ? minSize : Size;
                sum -= nums[i++];   //使滑动窗口不断往前移
            }
        }
    return minSize == INT32_MAX ? 0 : minSize;
    }
};

心得：要求连续的数组，要想到滑动窗口

解法二：暴力解法

LeetCode用暴力会超时
第一个for控制起始位置，遍历一遍数组，第二个for控制结束位置。

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

59.螺旋矩阵II

题目链接: https://leetcode.cn/problems/spiral-matrix-ii/
此题重在模拟过程，每次按顺时针处理矩阵一圈的四条边（因为是数字增大的规律是顺时针螺旋增加）
注意：1.要判断给的n是奇数还是偶数 2.处理边时，在左闭右开区间处理，这样处理每条边都是一样的流程

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> Matrix(n, vector<int>(n, 0));     //注意初始化二维数组写法
        int startX = 0, startY = 0;     //控制每一圈的起始矩阵的坐标
        int offset = 1;     //控制每一圈的边长
        int num = 1;        //起始数字
        int loop = n / 2;   //圈数
        while(loop --){   //n为偶数时，处理的圈数为n/2
            int i = startX, j = startY;
            for(; j < n - offset; j++){      //处理圈的上边，处理边注意要区间为左闭右开
                Matrix[startX][j] = num++;
            }
            for(; i < n - offset; i++){      //处理圈的右边
                Matrix[i][j] = num++;
            }
            for(; j > startY; j--){     //处理圈的下边 
                Matrix[i][j] = num++;
            }
            for(; i > startX; i--){     //处理圈的左边
                Matrix[i][startY] = num++;
            }
            startX++;
            startY++;
            offset++;
        }
        if(n % 2 == 1){     //n为偶数时，处理的圈数为n/2+1，故最后一圈单独处理
            Matrix[n /2][n /2] = num;
        }
        return Matrix;
    }
};```