算法训练营第2天

题目链接 977.有序数组的平方 & 209.长度最小的子数组 & 59.螺旋矩阵II

今日学习的文章链接 977.有序数组的平方 & 209.长度最小的子数组 & 59.螺旋矩阵II 和视频链接 977.有序数组的平方 & 209.长度最小的子数组 & 59.螺旋矩阵II

977.有序数组的平方

自己看到题目的第一想法

暴力:
如果使用sort()库函数还可以将时复提高到 O ( n l o g n ) O(nlogn) O(nlogn)

// 时间复杂度 O(n^2),空间复杂度 O(1)
class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        for (int i = 0; i < nums.size(); i++) {
            nums[i] = nums[i] * nums[i];
        }

        for (int i = 0; i < nums.size(); i++) {
            for (int j = i; j < nums.size(); j++) {
                if (nums[i] > nums[j]) {
                    nums[i] = nums[i] ^ nums[j];
                    nums[j] = nums[i] ^ nums[j];
                    nums[i] = nums[i] ^ nums[j];
                }
            }
        }

        return nums;
    }
};

前后双指针:
因为题干没要求原地求解,所以可以使用第二个数组。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> result(nums.size(), 0);

        for (int i = 0; i < nums.size(); i++) {
            nums[i] = nums[i] * nums[i];
        }

        for (int i = 0, j = nums.size() - 1, k = nums.size() - 1; i <= j; k--) {
            result[k] = nums[i] >= nums[j] ? nums[i++] : nums[j--];
        }

        return result;
    }
};

看完代码随想录之后的想法

与我的想法相同

自己实现过程中遇到哪些困难

构造一个指定长度的vector,使用条件运算符 ?:简化代码

今日收获,记录一下自己的学习时长

前后双指针、vector的构造、条件运算符?:

209.长度最小的子数组

自己看到题目的第一想法

拒绝两层for循环的暴力解法。使用快慢双指针达到 o ( n ) o(n) o(n)的时复。
有点像尺蠖,快指针寻找子数组的前端,慢指针在每次找到子数组后往前挪一位,同时sum减去这个值因为不属于新数组,此时快指针不需要移动,因为此时新生成一个子数组,需要先判断是否满足target

// 时复 O(n),空复 O(1)
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int i = 0, j = 0, sum = nums[0], length = nums.size();
        bool flag = false;

        while (i < nums.size() && j < nums.size()) {            

            if (sum < target) {                
                j++;
            } else {
                flag = true;
                length = (j - i + 1) < length ? (j - i + 1) : length;
                sum -= nums[i];
                i++;
                continue;
            }

            if (j < nums.size()) sum += nums[j];

        }
        
        return (flag == false) ? 0 : length;
    }
};

看完代码随想录之后的想法

原来有个专有名词滑动窗口,不过思想就是双指针
这里实现对于慢指针移动用的是while循环,好在不需要continue和特判,不过多了一个while我第一时间没想到,并且看上去好像有两个循环。不过这个方法比我的方法判断少一点儿。
滑动窗口,代码随想录思想,按照我的写法:

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int i = 0, j = 0, sum = 0, length = nums.size() + 1;

        for (; j < nums.size(); j++) {
            sum += nums[j];

            while (sum >= target) {
                length = (j - i + 1) < length ? (j - i + 1) : length;
                sum -= nums[i];
                i++;
            }

        }

        return (length == (nums.size() + 1)) ? 0 : length; 
    }
};

对我的第一想法的代码改进,因为在length等于全部元素数量时,可能是刚刚好或者没有符合条件的子数组,所以设置length初始值为nums.size() + 1即可解决这个判断。改进找不到子数组的情况:

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int i = 0, j = 0, sum = nums[0], length = nums.size() + 1;

        while (i < nums.size() && j < nums.size()) {            

            if (sum < target) {                
                j++;
            } else {
                length = (j - i + 1) < length ? (j - i + 1) : length;
                sum -= nums[i];
                i++;
                continue;
            }

            if (j < nums.size()) sum += nums[j];

        }
        
        return (length == nums.size() + 1) ? 0 : length;
    }
};

自己实现过程中遇到哪些困难

  1. 先判断再调整子数组,因为每次调整完都是一个新的子数组。这个顺序是我在手动模拟之后调整好的。
  2. 对于刚刚好或者不能找到子数组的,用flag判断其是否找到一个子数组。
  3. 对于边界的判断,测试用例3的越界情况,需要在调用nums[j]之前判断。

今日收获,记录一下自己的学习时长

59. 螺旋矩阵 II

自己看到题目的第一想法

应该是模拟,但是里面的判断较麻烦。

看完代码随想录之后的想法

为什么提到二分法?实际上是用到了循环不变量的思想。原来我自己在模拟的时候没有坚持循环不变量,也就是我并没有考虑区间,更没有考虑区间不变。
此处用了左闭右开区间,用到了每个循环的起点坐标,四个循环分为两类,一类是++,一类是–。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> result(n, vector<int>(n, 0));
        int start_x = 0, start_y = 0; // 每个圈开始的坐标,行列
        int loop = n / 2; // 完整的圈数,除了n = 1
        int middle = n / 2; // n为奇数时,矩阵中间的位置
        int count = 1; // 给矩阵元素赋值
        int offset = 1; // 每个方向循环的长度,每次循环右边界收缩一位
        int i, j; // 分别代表行列
        
        while (loop--) {
            i = start_x, j = start_y;

            // 接下来4个for循环模拟
            // 右
            for (; j < n - offset; j++) result[i][j] = count++;

            // 下
            for (; i < n - offset; i++) result[i][j] = count++;

            // 左
            for (; j > start_y; j--) result[i][j] = count++;

            // 上
            for (; i > start_x; i--) result[i][j] = count++;
 
            // 下一圈,开始坐标各加一
            start_x++, start_y++;

            // 每圈每条边的长度减少
            offset++;
        }

        // 当 n 为奇数的时候,中间的单独赋值
        if (n % 2 == 1) result[middle][middle] = count;

        return result;
    }
};

自己实现过程中遇到哪些困难

自己没有实现,应该多模拟几个找找规律

今日收获,记录一下自己的学习时长

这种题好像只能多做

  • 30
    点赞
  • 21
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值