代码随想录算法训练营Day 2|LeetCode977 有序数组的平方、Leetcode209 长度最小的子数组、Leetcode59 螺旋矩阵 II、Leetcode54 螺旋矩阵

最新推荐文章于 2024-05-31 13:35:03 发布

Marinx7

最新推荐文章于 2024-05-31 13:35:03 发布

阅读量3k

点赞数 27

文章标签：数据结构 leetcode c++

本文链接：https://blog.csdn.net/qq_52807368/article/details/135541241

版权

LeetCode977 有序数组的平方

题目链接：有序数组的平方

思路

暴力解先求平方后排序并不难想，但是这样时间复杂度只达到O(nlogn),于是想到了双指针，但是和随想录不太一样，本人思路：①遍历数组，寻找正负之间的“分界”，这个分界可能是0也可能是第一个正数；②若找到该分界，则可以从该分界分别向前和向后遍历，比较平方的最小值加入辅助数组；③若未找到分界，则说明该序列非负有序或非正有序，可根据两种不同情况按顺序取平方后加入辅助数组。

虽然时间复杂度勉强是O(n)，但是代码缝缝补补非常繁杂，甚至比O(nlogn)的暴力解执行时间还久，而且也不知道为啥当时想着按正负从中间分开，看到随想录上面的代码后感觉直接被秒杀...

代码随想录思路：

数组其实是有序的，只不过负数平方之后可能成为最大数了。

那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。

此时可以考虑双指针法了，i指向起始位置，j指向终止位置。

定义一个新数组result，和A数组一样的大小，让k指向result数组终止位置。

如果A[i] * A[i] < A[j] * A[j] 那么result[k--] = A[j] * A[j]; 。

如果A[i] * A[i] >= A[j] * A[j] 那么result[k--] = A[i] * A[i]; 。

代码

这里附上代码随想录的参考代码，本人代码太过丑陋就不贴了T T

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        int k = A.size() - 1;
        vector<int> result(A.size(), 0);
        for (int i = 0, j = A.size() - 1; i <= j;) { // 注意这里要i <= j，因为最后要处理两个元素
            if (A[i] * A[i] < A[j] * A[j])  {
                result[k--] = A[j] * A[j];
                j--;
            }
            else {
                result[k--] = A[i] * A[i];
                i++;
            }
        }
        return result;
    }
};

复杂度

时间复杂度 O(n)

空间复杂度O(n)

Leetcode209 长度最小的子数组

题目链接：长度最小的子数组

思路

一上来拿到题，除了O(n^2)的暴力解，没有啥思路，看资料讲到滑动窗口，学到一个比较重要的方法：若使复杂度为O(n)，只能使用一层for循环，for循环的索引一定表示滑动窗口的结束位置，而窗口起始利用while循环来滑动，求出每个符合sum>=target的窗口长度并及时更新最小窗口长度。

滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)暴力解法降为O(n)。

代码

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int i = 0;              //窗口起始
        int j = 0;              //窗口结束
        int MinLen = INT32_MAX; //最小窗口
        int TemLen = 0;         //当前窗口
        int sum = 0;
        bool flag = 0;
        for (j = 0; j < nums.size(); j++) {
            sum += nums[j];
            TemLen = j - i + 1;
            while (sum >= target) {
                if (MinLen > TemLen) {
                    MinLen = TemLen;
                    flag = 1; //标记MinLen已修改过
                }
                TemLen--;
                sum -= nums[i];
                i++;
            }
        }
        if (flag == 0)    //若MinLen未修改过
            MinLen = 0;
        return MinLen;
    }
};

复杂度

时间复杂度 O(n)

空间复杂度O(1)

Leetcode59 螺旋矩阵 II

题目链接：螺旋矩阵 II

思路

408中对二维数组代码要求较少，所以这一方面也算是一个漏洞，一上来也没啥想法，在看完随想录的视频后还是清晰了不少，关于循环不变量原则也回头看了相关文章二分法

代码随想录思路：

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

填充上行从左到右
填充右列从上到下
填充下行从右到左
填充左列从下到上

左闭右开绕圈，注意圈数应为n/2，最后处理奇数方阵时的中间元素，将其插入到result。

代码

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> result(n, vector<int>(n, 0)); //辅助数组
        int startx = 0, starty = 0,
            offset = 0; //其实可以定义为一个变量，为了方便理解分开定义
        int i = 0, j = 0;
        int count = 1;
        int loop = n / 2,
            mid = n / 2; // lopp用于循环，mid用于当n为奇数时处理中间数
        while (loop--) { //转n/2圈
            i = startx;
            j = starty;
            //开始绕圈,均左闭右开
            for (j = starty; j < n - offset - 1; j++) { //上侧边
                result[startx][j] = count++;
            }
            for (i = startx; i < n - offset - 1; i++) { //右侧边
                result[i][j] = count++;
            }
            for (; j > starty; j--) { //下侧边
                result[i][j] = count++;
            }
            for (; i > startx; i--) { //左侧边
                result[i][j] = count++;
            }
            startx++;
            starty++;
            offset++;
        }
        if (n % 2 == 1) { //若n为奇数，最后一圈即为单个数，单独处理
            result[mid][mid] = count;
        }
        return result;
    }
};

复杂度

时间复杂度 O(n^2)

空间复杂度O(1)

Leetcode54 螺旋矩阵

题目链接：螺旋矩阵

思路

有了上一题的铺垫，本题做起来算是有了方向，基本思想还是先绕圈，再处理特殊情况：①若行数大于列数，且列数为奇数，则当转圈后还剩一行元素待插入；②若列数大于行数，且行数为奇数，则当转圈后还剩一列元素待插入；③同上题奇数阶方阵，只需处理一个中间元素。

代码

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        int m = matrix.size();    //行数
        int n = matrix[0].size(); //列数
        if (matrix.empty())
            return {};
        vector<int> result(m * n, 0); //结果数组
        int loop = min(m / 2, n / 2); //确定圈数
        int startx = 0, starty = 0;
        int i = 0, j = 0;
        int count = 0, offset = 0;
        while (loop--) {
            i = startx;
            j = starty;
            //开始转圈，左闭右开
            for (; j < n - offset - 1; j++) {
                result[count++] = matrix[i][j];
            }
            for (; i < m - offset - 1; i++) {
                result[count++] = matrix[i][j];
            }
            for (; j > starty; j--) {
                result[count++] = matrix[i][j];
            }
            for (; i > startx; i--) {
                result[count++] = matrix[i][j];
            }
            startx++;
            starty++;
            offset++;
        }
        //此时仅处理一行或一列，需左右均闭
        if (m > n && n % 2 == 1) { //若行数大于列数(奇数时)，转圈后还剩一行元素
            for (startx; startx < m - offset; startx++) {
                result[count++] = matrix[startx][starty];
            }
        } else if (n > m &&
                   m % 2 == 1) { //若列数大于行数(奇数时)，转圈后还剩一列元素
            for (starty; starty < n - offset; starty++) {
                result[count++] = matrix[startx][starty];
            }
        } else if (m == n && m % 2 == 1) { //若为奇数阶方阵,转圈后还剩一个元素
            result[count++] = matrix[n / 2][n / 2];
        }
        return result;
    }
};

复杂度

时间复杂度 O(mn) 其中m、n分别为矩阵的行列

空间复杂度O(mn)

总结

像滑动窗口、螺旋矩阵这样的题方法性比较强，一开始看到题都断了思路，也是理解了为啥卡哥推荐先看视频和文章之后再做题，以后一定改T T

Marinx7

关注

27
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营Day 2|LeetCode977 有序数组的平方、Leetcode209 长度最小的子数组、Leetcode59 螺旋矩阵 II、Leetcode54 螺旋矩阵

像滑动窗口、螺旋矩阵这样的题方法性比较强，一开始看到题都断了思路，也是理解了为啥卡哥推荐先看视频和文章之后再做题，以后一定改T T。
复制链接

扫一扫