day02| 977.有序数组的平方 ,209.长度最小的子数组 ,59.螺旋矩阵II ,总结

977.有序数组的平方

leetcode题目链接

给你一个按 非递减顺序 排序的整数数组 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]

能写出暴力解法,先计算平方然后再排序。嗯,sort函数真好用。O(n+nlogn)

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int size = nums.size();
        for (int i=0; i<size; i++){
            nums[i]=nums[i]*nums[i];
        }
        sort(nums.begin(), nums.end());
        return nums;
    }
};

根据提示我自己写的双指针解法,能对一部分但是并不完全正确。

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

正确解法。时间复杂度为O(n)

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

根据代码随想录的解答修改我自己的答案

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int size = nums.size();
        int k = size - 1;
        vector<int> result(nums.size(), 0);
        for(int a = 0, b=size-1; b>=a;){//重点:这里需要=号。两个指针可以定义在for循环里(a和b)。终止条件都可以是变量。
            if(nums[a]*nums[a]>nums[b]*nums[b]){
            result[k--] = nums[a]*nums[a];//学习这种每一步赋值后都要往前一步的写法,即k--
            a++;//终止条件的变量可以写在for的函数体里面。
            }else{
                result[k--] = nums[b]*nums[b];
                b--;//同上。
            }
        }
        return result; 
    }
};

209.长度最小的子数组

leetcode题目链接

给定一个含有 n 个正整数的数组和一个正整数 s ,找出该数组中满足其和 ≥ s 的长度最小的 连续
子数组,并返回其长度。如果不存在符合条件的子数组,返回 0。

示例:

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

我自己看着代码随想录滑动窗口(本质是双指针)解法的那个动态图来写的。能通过leetcode中2,3示例,所以我这个写法得到的结果是从左到右第一个符合条件的子数组,但不是最小子数组
我一开始看错题目了,我以为要计算的是等于target的最小子数组,其实题目是要大于等于。所以下面我写的代码也不是符合题目要求的。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int N;
        for(int i = 0, j = 0; i<nums.size() - 1;){
            //计算i和j之间的数组和(只能用循环计算吗)
            N = 0;
            for(int a = i; a <= j; a++){
                N = N + nums[a];
            }
            if(N == target){
                return j - i + 1;
            }
            if(N < target){
                j++;
            }
            if(N > target){
                i++;
            }
            if(j > nums.size() - 1){
                break;
            }
        }
        return 0;
    }
};

抄的代码随想录的暴力解法

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++){
            sum = 0;
            for(int j = i; j<nums.size(); j++){
                sum = sum + nums[j];
                if(sum >= target){
                    subLength = j - i + 1;
                    result = result < subLength ? result : subLength; //这个倒是可以解决我上面那个不能找最小数组的缺陷,但是这个是需要找到全部的组合,估计只能适合暴力解法。
                    break;
                }
            }
        }
        return result==INT32_MAX ? 0 : result;
    }
};

代码随想录中,从暴力解法优化来的滑动窗口解法。

//这个滑动窗口代码是从暴力解法优化过来的,很有思考价值
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int result = INT32_MAX;
        int sum = 0;
        int subLength = 0;
        int i = 0;//加的
        for (int j = 0; j<nums.size(); j++){ //i变成j,外层for循环控制结束位置
            sum = sum + nums[j];
            while(sum >= target){//把原本if的判断写在了while的执行条件里
                subLength = j - i + 1;
                result = result < subLength ? result : subLength;
                sum = sum - nums[i++];//这里其实做了两件事,一个是动态去掉了滑动窗口的前面一个数组值,即缩小滑动窗口,另一个是将指针i后移。嗯,我发现作者好像很喜欢这种数组里取值再直接加减的写法,确实很简洁,可以学学。
            }
            //下面注释的是暴力解法
            // for(int j = i; j
            //     sum = sum + nums[j];
            //     if(sum >= target){
            //         subLength = j - i + 1;
            //         result = result < subLength ? result : subLength;
            //         break;
            //     }
            // }
        }
        return result==INT32_MAX ? 0 : result;
    }
};

59.螺旋矩阵II

leetcode题目链接

给定一个正整数 n,生成一个包含 1 到 n^2 所有元素,且元素按顺时针顺序螺旋排列的正方形矩阵。

示例:

输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

有个疑问,二维数组的题目是不是至少都是O(n^2)的时间复杂度?

这个题没有算法,就是纯模拟。重要的是处理四个边界都要坚持左闭右开。循环不变量

总结

数组这一章学习了二分法和双指针法(滑动窗口实质是双指针)。都可以降低暴力解法的时间复杂度。

学习链接

代码随想录

你可能感兴趣的:(刷题,算法,矩阵,leetcode)