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

977. 有序数组的平方

想法：有序数组的最值只会出现在两侧

进行两边进行缩进（双指针）

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int index = nums.size()-1;
        vector<int> ans(nums.size());
        int left = 0;
        int right = nums.size()-1;
        while(left<=right) {
            if(nums[left]*nums[left] <= nums[right]*nums[right]) {
                ans[index--] = nums[right]*nums[right];
                right--;
            }else {
                ans[index--] = nums[left]*nums[left];
                left++;
            }
        }
        return ans;
    }
};

暴力解法：全部平方，再进行排序

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

209. 长度最小的子数组

想法：需要用到滑动窗口，进行两边边界的缩进（os: 但是好难考虑情况）

阅读后想法：终止位置进行移动，当满足条件后，再移动起始位置

滑动窗口重点：终止位置

a. 当右边界移动到已经满足条件下，左边界需要进行移动，因为已经没有意义继续移动右边界，需要考虑缩小窗口、改变窗口区间

b. 右边界可以移动到最后一位，左边界继续进行最后一个终止位置的缩进判断（是否满足），如果不满足，此时右边界也进行了++的操作，因此会退出循环

思路：

a. 如果移动终止位置，起始位置的值不是从0开始，这个区间是移动的；进加入的这个终止位置的值，能否带来更短的区间

b. 如果移动起始位置，（累加的值是未知的），终止位置的移动必须全部遍历slow后面索引

c. 缩进左边界的边界条件：slow=fast，在slow=fast-1的时候，如果只需要一个元素就可以满足的话，下次累加区间应该为0，重新开始

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int fast = 0;
        int slow = 0;
        int sum = 0;
        int MinLength = 1e9;
        while(fast<nums.size()) {
            sum += nums[fast];
            while(sum>=target) {
                // 满足情况
                MinLength = min(MinLength, fast-slow+1);
                sum -= nums[slow];
                slow++;
            }
            fast++;
        }
        return MinLength==1e9?0:MinLength;
    }
};

59.螺旋矩阵II

想法：考虑需要转几圈，进行从左到右，从上到下，边界判断

奇偶判断：偶数转完刚好；奇数还需要补中间

每轮边界的判断（offset），每轮起始判断（startIndex），每轮遍历值（i）

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> ans(n, vector<int>(n, 0));
        int startX = 0;
        int startY = 0;
        int offset = 1;
        int i = 0; // 行
        int j = 0; // 列
        int index = 1; // 值
        int loop = n/2;
        
        while(loop--) {
            i = startX;
            j = startY;
            // 从左到右边
            for(; j<n-offset; j++) {
                ans[i][j] = index++;
            }
            // 从上到下
            for(;i<n-offset; i++) {
                ans[i][j] = index++;
            }
            // 从右到左
            for(;j>startY; j--) {
                ans[i][j] = index++;
            }
            // 从下到上
            for(;i>startX; i--) {
                ans[i][j] = index++;
            }
            startX++;
            startY++;
            offset++;
        }
        if(n%2==1) {
            ans[startX][startY] = index;
        }
        return ans;

    }
};