代码随想录算法训练营第二天 |LeetCode 977.有序数组的平方 209.长度最小的子数组 59.螺旋矩阵II

977.有序数组的平方 

题目链接：. - 力扣（LeetCode）

看到题目的第一想法：分两步，先全部平方，再做排序;一个for循环来平方；一个嵌套双for来做排序,利用两个int变量作为存储low和hig并交换的工具

自己写的代码1.0：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int remlow=0,remhig=0;
        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+1;j<nums.size();j++){
                if(nums[i]>nums[j]){
                    remlow=nums[j];
                    remhig=nums[i];
                    nums[j]=remhig;
                    nums[i]=remlow;

                }
            }
        }
           return nums;
    }
};

看完代码随想录之后的想法：我对于具体问题的规律的寻找不够，没有想到关键在于负数的处理，即平方之后最大值会出现在两头

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

用新建数组以及双指针来避免循环嵌套；这里的for循环的这种使用方法也是之前没见过的，可以不写i++在条件代码块里i++，而且能够一次初始化多个变量

209.长度最小的子数组

题目链接：. - 力扣（LeetCode）

看到题目的第一想法：双指针（fast slow）做滑动窗口,用双for循环嵌套；用int型的lenlow来存储最小长度

自己写的代码1.0：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int sum=0,j=0,len=0,lenlow=nums.size()+1,start=0;
        
            for(int fast=0;fast<nums.size();fast++){
                sum=sum+nums[fast];
                for(int slow=start;slow<=fast;slow++){
                 if(sum>=target){
                    len=fast-slow+1; 
                    sum=sum-nums[slow];
                    if(len<lenlow){
                    lenlow=len;
                        }
                        start=slow+1;
                        }
    
                    }
                }
           
       if(lenlow==nums.size()+1){
            return 0;
        }
        else{
             return lenlow;
        }
        
    }
};

暴力算法，可以运行，但是对于很大的数组会超时

看完代码随想录之后的想法：我写的代码问题在于slow不需要用for进行循环，我用for的目的是缩小窗口到窗口中的数和小于target，没有想到用while实现循环和判断，对c++中常用的语法不够熟悉

自己写的代码2.0：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int sum=0,j=0,len=0,slow=0,lenlow=nums.size()+1,start=0;
        
            for(int fast=0;fast<nums.size();fast++){
                sum=sum+nums[fast];
               while(sum>=target){
                    len=fast-slow+1; 
                    sum=sum-nums[slow];
                    if(len<lenlow){
                    lenlow=len;
                        }
                        start=slow++;
                        }
                        
    
                    }
                if(lenlow==nums.size()+1){
            return 0;
        }
        else{
             return lenlow;
        } 
    }      
};

优化3.0：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int result = INT32_MAX;
        int sum = 0;
        int slow = 0;
        int Lenlow = 0;
        for (int fast = 0; fast < nums.size(); fast++) {
            sum += nums[fast];
            while (sum >= target) {
                Lenlow = (fast - slow + 1); 
                result = result < Lenlow ? result : Lenlow;
                sum -= nums[slow++]; 
            }
        }
        return result == INT32_MAX ? 0 : result;
    }
};

用条件运算符代替if，这样代码更加简洁且运算速度更快，INT32_MAX这个常量之前没见过

59.螺旋矩阵II

题目链接：. - 力扣（LeetCode）

看到题目的第一想法：先生成一个n维矩阵，然后按照先行加再列加再行减，但加后再减这种需要不同的判断条件实现循环并不好写；用左闭右开的变动区间做for循环,按照加y，加x，减y，减x循环

看完代码随想录之后的想法：我对于具体问题的规律的寻找不够本质，看到螺旋就把规律看成了螺旋，没有想到转圈；另外对于c++的for循环语法不够了解，不知道for可以不写初始化，以及把i,j看成了局部变量；不会定义二维数组

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> matrix_2(n,vector<int>(n,0));
        int start_h = 0, start_l = 0, reb = 1,count = 1,i,j;
        for(int cir = n/2; cir > 0; cir--){
            for(j = start_l; j < n-reb; j++){
                matrix_2[start_h][j] = count ++;
            }
            for(i = start_h; i < n-reb; i++){
                matrix_2[i][n-reb] = count ++;
            }
            for(; j > start_l; j--){
                matrix_2[n-reb][j] = count ++;
            }
            for(; i > start_h; i--){
                matrix_2[i][start_l] = count ++;
            }
            start_h ++;
            start_l ++;
            reb ++;
        }
        if(n % 2 == 1){
            matrix_2[start_h][start_l] = count;
        }
        return matrix_2;
    }
};