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

SuperYue37

已于 2023-01-13 22:31:45 修改

阅读量3.5k

点赞数

分类专栏：代码随想录文章标签：算法矩阵 leetcode Powered by 金山文档

于 2023-01-12 21:04:08 首次发布

本文链接：https://blog.csdn.net/weixin_41275864/article/details/128666366

版权

代码随想录专栏收录该内容

10 篇文章 0 订阅

订阅专栏

LeetCode977. 有序数组的平方

题目链接：https://leetcode.cn/problems/squares-of-a-sorted-array/

思路：看到题目的第一想法是使用暴力法：数组里的每个元素都平方一下，再排个序。

C++代码如下：

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

思考：可以使用双指针法。题目说了数组是有序的，那么该数组平方的最大值就在数组的两端，要么最左边，要么最右边，不可能在中间。

考虑用双指针法，i指向原数组起始位置，j指向原数组终止位置。

再定义一个新的数组，用于存放最终结果，和原数组一样的大小。

如果A[i]*A[i] ≤ A[j]*A[j]，那么result[k] = A[j]*A[j]，k- -，j- -；

如果A[i]*A[i] > A[j]*A[j]，那么result[k] = A[i]*A[i]，k- -，i++；

C++代码如下：

class Solution 
{
public:
    vector<int> sortedSquares(vector<int>& nums) 
    {
        vector<int> A(nums.size(), 0);  //最后的结果存放在这个新数组中
        int i = 0;
        int j = nums.size() - 1;
        int len = nums.size() - 1;

        while(i < j)
        {
            if((nums[i]*nums[i]) <= (nums[j]*nums[j]))
            {
                A[len] = nums[j]*nums[j];
                len--;
                j--;
            }
            else if((nums[i] * nums[i]) > (nums[j] * nums[j]))
            {
                A[len] = nums[i]* nums[i];
                len--;
                i++;
            }
        }
        A[0] = nums[i] * nums[i];
        return A;
    }
};

LeetCode209. 长度最小的子数组

题目链接：https://leetcode.cn/problems/minimum-size-subarray-sum/

思路：暴力法，用两层for循环，不断寻找符合条件的子序列，再找出长度最短的子序列。时间复杂度：O(n^2)。

C++代码如下：

class Solution 
{
public:
    int minSubArrayLen(int target, 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 >= target)   //若子序列之和超过target，更新result
                {
                    subLength = j - i + 1;  //子序列长度
                    result = result < subLength ? result : subLength;
                    break;   //因为找的是符合条件的最短的子序列，所以符合条件后子序列没必要继续累加了。所以弹出该循环去更新子序列的起点找新的符合条件的子序列。
                }
            }

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

思考：

使用滑动窗口，其实我把它也理解成是双指针法（快慢指针法）。

在上面的暴力法中，是一个for循环为滑动窗口的起始位置，一个for循环为滑动窗口的终止位置，用两个for循环完成了一个不断搜索区间的过程。

我用双指针法在一个for循环下完成两个for循环的工作。

定义快慢指针

快指针：指向子序列的终点位置

慢指针：指向子序列的起始位置

每次fastIndex移动时，都会把子序列的数值累加起来与target比较，若小于target，则进入下一个循环，fastIndex继续移动，寻找符合条件的子序列；

当子序列的数值累加后大于等于target，即符合条件，计算当前子序列的长度，并与result比较，把较小的更新为最新的result。更新result之后子序列数值之和还要减去slowIndex指向的数值，并向前移动slowIndex，因为我们要寻找符合条件的最短的子序列：1.如果不移动slowIndex而是继续移动fastIndex，就没必要了，因为后面的子序列肯定比当前的要长；2.同时，有可能减去当前slowIndex指向的数值后的子序列仍旧符合条件，所以，在找到符合条件的子序列后要移动slowIndex，更新子序列再继续判断是否符合条件。

C++代码如下：

class Solution 
{
public:
    int minSubArrayLen(int target, vector<int>& nums) 
    {
        int sum = 0;  //子序列元素之和
        int slowIndex = 0;
        int fastIndex = 0; 
        int subLength = 0;   //子序列长度
        int result = INT32_MAX;

        for(fastIndex = 0; fastIndex < nums.size(); fastIndex++)
        {
            sum += nums[fastIndex];
            while(sum >= target)
            {
                subLength = fastIndex - slowIndex + 1;
                result = result < subLength ? result : subLength;
                sum -= nums[slowIndex];
                slowIndex++;
            }
            if((fastIndex==nums.size()-1)&&(slowIndex==0)&&(sum < target))   //如果整个数组都加起来也小于target，则直接返回0。
            {
                result = 0;
            }
        }
        return result;
    }
};

LeetCode59. 螺旋矩阵II

题目链接：https://leetcode.cn/problems/spiral-matrix-ii/

思路：一开始的想法是把n=1~5全部列出来，再找规律，但是后来没有写出来。现做法就是模拟过程，一步一步写出来。

模拟顺时针画矩阵的过程：

填充上行从左到右

填充右列从上到下

填充下行从右到左

填充左列从下到上

由外向内一圈圈画下去。

代码中画的每一条边，都按照左闭右开的原则：

这里每一种颜色，代表一条边，可以看到每一个拐角处的处理规则，拐角处让给新的一条边来继续画，此处都是按照左闭右开的原则。

C++代码如下：

class Solution 
{
public:
    vector<vector<int>> generateMatrix(int n) 
    {
        vector<vector<int>> res(n, vector<int>(n, 0));   //使用vector定义一个二维数组，vector<int>(n, 0)指初始化一个vector<int>类型数组，容量为n，初始值为0
        int startx = 0, starty = 0;  //定义每循环一个圈的起始位置
        int loop = n / 2;  //每个圈循环几次，例如n为奇数3，那么loop = 1只是循环一圈，矩阵中间的值需要单独处理
        int mid = n / 2;   //矩阵中间的位置，例如：n为3，中间的位置就是(1,1), n为5，中间的位置就是(2,2)
        int count = 1;     //用来给矩阵中每一个空格赋值
        int offset = 1;    //需要控制每一条边遍历的长度，每次循环右边界收缩一位
        int i, j;

        while(loop--)
        {
            i = startx;
            j = starty;

            //下面开始的四个for就是模拟转了一圈
            //模拟填充上行从左到右(左闭右开)
            for(j = starty; j < n - offset; j++)
            {
                res[startx][j] = count;
                count++;
            }
            //模拟填充右列从上到下(左闭右开)
            for(i = startx; i < n - offset; i++)
            {
                res[i][j] = count;
                count++;
            }
            //模拟填充下行从右到左(左闭右开)
            for(; j > starty; j--)
            {
                res[i][j] = count;
                count++;
            }
            //模拟填充左列从下到上(左闭右开)
            for(; i > startx; i--)
            {
                res[i][j] = count;
                count++;
            }

            //第二圈开始的时候，起始位置要各自加1，例如：第一圈起始位置是(0,0)，第二圈起始位置是(1,1)
            startx++;
            starty++;

            //offset 控制每一圈里每一条边遍历的长度
            offset += 1;
        }
        //如果n为奇数，需要单独给矩阵最中间的位置赋值
        if(n % 2)
        {
            res[mid][mid] = count;
        }
        return res;
    }
};

今日总结：螺旋矩阵不熟，要多练习。长度最小的子数组这题，倒是想到了用双指针法，后续可再回顾。