代码随想录算法训练营第二天

今天回家早，但是刚到家刷视频一直到10点多，洗漱完都11点，写完几个代码题都感到12点了，可想而知明天上班又会犯困，以后先把题写了剩下时间在玩吧

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]

解答代码

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

        }
        return result;
    }
};

注意大小顺序，是result是从小到大，但是双指针是指向平方和最大的那个，需要注意一下。

另外注意vector的创建规则，别写错了

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

错误代码：

class Solution
 {
public:
    int minSubArrayLen(int target, vector<int>& nums) 
    {
        int slow = 0;

        int add = 0;
        int ans = INT32_MAX;

        for(int fast = 0;fast < nums.size() ;fast++)
        {
            add += nums[fast];
            while(add >= target)//出现大的了使用滑动窗口，用while不断缩小窗口的值
            {
                add -= nums[slow];
                slow++;
                ans = min(ans,fast - slow + 1);//使用完fast遍历数组后取最小的那个ans

            }//这里有问题，fast-slow+1的判断太靠后了
        }
        return ans = max(0,ans);

    }
};

在while循环中对fast-slow+1的判断不应该在slow变动之后进行。另外return也出错了，需要判断ans是否为0（即整个数组的和也不满足），而不是简单的和0比

正确答案：

class Solution
 {
public:
    int minSubArrayLen(int target, vector<int>& nums) 
    {
        int slow = 0;

        int add = 0;
        int ans = INT32_MAX;

        for(int fast = 0;fast < nums.size() ;fast++)
        {
            add += nums[fast];
            while(add >= target)//出现大的了使用滑动窗口，用while不断缩小窗口的值
            {
                int a = fast - slow + 1;
                add -= nums[slow];
                slow++;
                ans = min(ans,a);//使用完fast遍历数组后取最小的那个ans

            }
        }
        return ans == INT32_MAX ? 0 : ans;

    }
};

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]]

基本思想，先把数填到二维数组中，在按行输出；

错误代码

class Solution 
{
public:
    vector<vector<int>> generateMatrix(int n) 
    {
        int inner = 1;
        vector<vector<int>> arry(n,vector<int>(n,0));
        int i = 0, j = 0;
        int loop = n/2;
        int length = n - 1;
        int back = 0;
        while(loop--)
        {
            for(;j < length; j++)
            {
                arry[i][j] = inner++;
            }
            for(;i < length; i++)
            {
                arry[i][j] = inner++;
            }
            for(;j > back ; j--)
            {
                arry[i][j] = inner++;
            }
            for(; i > back ;i--)
            {
                arry[i][j] = inner++;
            }
            length--;
            back++;




        }
        if(n%2 != 0)//这里需要单独拿出去给最中间赋值，并且要判断n是不是偶数，
        {
            arry[n/2][n/2] = inner;
        }

        return arry;
    }
};

对i，j的判断太冗余了，除了左闭右开，还需要考虑每次循环的初始位置

正确代码：

使用go判断ij增大，用back判断ij减少，loop判断循环次数，start控制初始位置，

注意第一个for中不能写成i，j = start，cpp语言只会给j赋值，这样会导致错误，应该是底层逻辑的问题

class Solution 
{
public:
    vector<vector<int>> generateMatrix(int n) 
    {
        int inner = 1;
        vector<vector<int>> arry(n,vector<int>(n,0));
        int i = 0, j = 0;
        int loop = n/2;
        int start = 0;
        int go = n-1;
        int back = 0;
        while(loop--)
        {
            for(i = start,j = start;j < go ; j++)
            {
                arry[i][j] = inner++;
            }
            for(;i < go; i++)
            {
                arry[i][j] = inner++;
            }
            for(;j > back ; j--)
            {
                arry[i][j] = inner++;
            }
            for(; i > back ;i--)
            {
                arry[i][j] = inner++;
            }
            start++;
            go--;
            back++;



        }
        if(n%2 != 0)//这里需要单独拿出去给最中间赋值，并且要判断n是不是偶数，
        {
            arry[n/2][n/2] = inner;
        }

        return arry;
    }
};

 发现了一个变量更少的写法，并且好像使用while循环比使用for循环消耗的时间更少

class Solution 
{
public:
    vector<vector<int>> generateMatrix(int n) 
    {
        vector<vector<int>> arr(n,vector<int>(n,0));
        int offset = 0;//只用一个offset可以不用写很多其他的变量
        int value = 1;
        int i = 0,j = 0;
        while(value < n*n)
        {
            for(j = offset,i = offset; j < n - 1 - offset; j++)
            {
                arr[i][j] = value++;
            }
            for(; i < n - 1 - offset; i++)
            {
                arr[i][j] = value++;
            }
            for(i = n - 1 - offset, j = n -1 - offset; j > offset; j--)
            {
                arr[i][j] = value++;
            }           
            for(; i > offset; i--)
            {
                arr[i][j] = value++;
            }
            offset++;
        }
        if(n%2 == 1)
        {
            arr[n/2][n/2] = value;
        }
        return arr;
    }
};