LeetCode 第二天

977.有序数组的平方

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

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

提示：

1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 已按 非递减顺序 排序

思路：最开始只会用暴力排序，但是太无聊了，就去看了卡哥的双指针。原理其实类似于归并排序，只是最开始我本来想找中间最小点来归并，但是感觉有点麻烦，就去看了题解，其实就是用vector把数组先开辟好，从后往前归并，直到前角标i == 后角标j即可停止。归并当然不可避免的会产生一个O（n）的空间消耗。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) 
    {
        //双指针，类似于归并排序
        int n = nums.size();
        int k = n-1,j = n-1,i = 0;
        vector<int> vec(n,0);
        while(i <= j)
        {
            if(nums[i]*nums[i] < nums[j]*nums[j])
            {
                vec[k--] = nums[j]*nums[j];
                j--;
            }
            else
            {
                vec[k--] = nums[i] * nums[i];
                i++;
            }
        }
        return vec;
        
    }
};

题目连接：209 长度最小的子数组
给定一个含有 n 个正整数的数组和一个正整数 target 。

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

示例 1：

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
示例 2：

输入：target = 4, nums = [1,4,4]
输出：1
示例 3：

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

提示：

1 <= target <= 109
1 <= nums.length <= 105
1 <= nums[i] <= 105

思路：最开始我想的是动态规划，就是那种找最大子序列，但是太菜了想不到，也看了题解。本质上就是两个指针i j，j向后探索更大序列，满足子序列和大于target值时i 也向后缩小序列值，主打一个调和。感觉可以打个讲价的比方，我先讲一个数（j），卖家说OK这个价可以卖，但是我又觉得说高了，一步一步再说少点试探低价（i），最终低于商家最低价，不同意卖了。但是此时我已经套到了商家的底价，即我要求得结果。当然这只是一个轮次，整个序列可能有多个轮次。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int sum = 0;//记录窗口内数的总和
        int len = 0;//记录滑动窗口长度
        int result = INT32_MAX;//记录结果，每次和滑动窗口比较得出较小值，因此初始要取最大
        int i = 0;//起始位置
        for(int j = 0;j < nums.size();j++)
        {
            sum += nums[j];
            while(sum >= target)//当大于目标值时，起始指针向后移
            {
                len = j - i + 1;//这一次的窗口长度
                result = result < len?result:len;//同历次窗口大小做对比
                sum -= nums[i];
                i++;
            }
        }
        return result == INT32_MAX?0:result;//如果定义的结果值未更改，表明没有合适的子数组
    }
};

59 螺旋矩阵II

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

示例 1：

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]
示例 2：

输入：n = 1
输出：[[1]]

思路：找到循环不变量，不必每次都去判断不同边界，处理各种复杂情况。其实也就是找到每次循环的共性。在这一题中关键点就在于将每一圈当做一个循环，每一个循环中都分为四个步骤，即向右，向下，向左，向上，同时每个方向遵从左闭右开原则，这样就不用考虑每个角的特殊情况。同时设置offset偏移量来记录每次圈缩小范围。总的遍历次数为n/2次，因为每次一圈可以走完两行两列，总共n行n列。最后注意n为奇数时需要单独在中间点赋值。

class Solution {
public:
    int d[4][2] = {{1,0},{0,-1},{-1,0},{0,1}};//方向：右下左上
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n,vector<int>(n,0));//必须初始化，分配内存空间才可以采用数组下标来取数存数
        int startx=0,starty=0;//起始角标
        int offset = 1;
        int count = 1;  
        int loop = n/2;
        int i,j;
        while(loop--)//每次遍历可以覆盖两行，因此总共n/2次遍历
        {
            i = startx;//最开始我想ij角标是否可以省略，但是因为要用他们遍历每一行，因此保留比较好理解
            j = starty;
            for(j = starty;j<n-offset;j++)//循环从左到右，左闭右开原则
            {
                res[i][j] = count++;
            }
            for(i = startx;i<n-offset;i++)//循环从上到下
            {
                res[i][j] = count++;
            }
            for(;j>starty;j--)//循环从右到左
            {
                res[i][j] = count++;
            }
            for(;i>startx;i--)//循环从下到上
            {
                res[i][j] = count++;
            }
            startx++;//遍历到最后起始位置到对角线下一个点
            starty++;
            offset++;//同时左闭右开区间的偏移量加一
        }
        if(n%2 != 0)//n是奇数,中心点需要单独处理
        {
            res[n/2][n/2] = count;
        }
        return res;
    }
};