代码随想录 DAY2 打卡

有序数组的平方：

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

对应力扣977题

两种解法

暴力解法：

解答思路就是将数组中的所有元素平方之后，使用一种排序算法进行排序即可（比如说快速排序），这里我直接使用了vector中的sort函数进行排序。

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

另外一种思路就是使用双指针，使用两个指针分别代表数组的起始点和结束点，因为平方后的数组最大的数都在两侧，比如说{-3，1，2，4}平方之后就变成{9，1，4，16}，可以看到左右两侧的数较大，中间的数较小，这个时候我们新开一个数组，将i和j所指向的数进行比较，较大的填入新开数组的尾部,这张图片非常形象↓

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

长度最小的子数组

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

示例：

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

对应力扣209题

一是暴力解法直接双重for循环

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
       int sum=0,flag=INT32_MAX;
       for(int i=0;i<nums.size();i++)
       {for(int j=i;j<nums.size();j++)
       {    sum+=nums[j];
           if(sum>=target&&j-i+1<flag)
            {flag=j-i+1;   
            }
       }
       sum=0;
       }
      if(flag!=INT32_MAX)
      return flag;
      else
      return 0;
    }
};

时间复杂度不够，有几个超时了，但是基本思路没什么问题。

二是滑动窗口

所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。

图片非常形象👇

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
       int sum=0,flag=INT32_MAX;
       int j=0;
      for(int i=0;i<nums.size();i++)
      {  sum+=nums[i];
         while(sum>=target)
         {  flag=min(flag,i-j+1);
            sum-=nums[j];
            j++;
         }
      }
      if(flag==INT32_MAX)
      return 0;
      else
      return flag;
    }
};

螺旋矩阵II

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

示例:

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

非常重要的一件事，需要判定边界条件，我这里也是使用左闭右开区间，右边的数不在区间内。

因为这个条件，代码中需要加入offset量↓

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
    vector<vector<int>> res(n,vector<int>(n,0));
     int begin_x=0,begin_y=0;
     int offset=1;
     int count=1;
     int j,i=0;
     int flag=n/2;
     while(flag)
     { for(j=begin_y;j<n-offset;j++)
       res[i][j]=count++;
       for(i=begin_x;i<n-offset;i++)
       res[i][j]=count++;
       for(;j>begin_y;j--)
       res[i][j]=count++;
       for(;i>begin_x;i--)
       res[i][j]=count++;
       begin_x++,begin_y++;
       i=begin_x;
       offset++;
       flag--;
     }
     if(n%2)
     res[n/2][n/2]=n*n;
     return res;
    }
};

还有一种做法，方向法，想到这个的人太牛了

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
    vector<vector<int>> res(n,vector<int>(n,0));
    int dx[]={0,1,0,-1};
    int dy[]={1,0,-1,0};
    int a=0,b=0;
    int d=0;//方向
    int x=0,y=0;
    for(int k=1;k<=n*n;k++)
    {   res[x][y]=k;
       a=x+dx[d];b=y+dy[d];
       if(a<0||a>=n||b<0||b>=n||res[a][b])
        {    d=(d+1)%4;
             a=x+dx[d];b=y+dy[d];
        }
        x=a;y=b;
    }
     return res;
    }
};

还有相关的练习题没有练习，看看明天有没有时间练一下，不练等于白刷。