Day2_算法训练营第二天 |977.有序数组的平方 ，209.长度最小的子数组 ，59.螺旋矩阵

一、提要

        今天第一天学习的是数组的内容，具体算法有关的是双指针和数组中移除元素，在力扣中的具体题目是977.有序数组的平方 ，209.长度最小的子数组 ，59.螺旋矩阵，并且有附加题目如下。

二、附加题目

1.长度最小的子数组

• 904.水果成篮(opens new window)                        已完成
• 76.最小覆盖子串

2.螺旋矩阵

• 54.螺旋矩阵(opens new window)                          已完成
• 剑指Offer 29.顺时针打印矩阵(opens new window)

 三、题目完成AC代码

part1：

977.有序数组的平方 

1、很简单的思路平方取出来，排序（暴力）

2、运用了两个指针的办法（像是双指针的前传）

/*
977. 有序数组的平方
简单
相关标签
相关企业
给你一个按 非递减顺序 排序的整数数组 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]
提示：
1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 已按 非递减顺序 排序
进阶：
请你设计时间复杂度为 O(n) 的算法解决本问题
*/

//这一次是纯纯的暴力哈哈哈哈哈哈
#include<bits/stdc++.h>
using namespace std;

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 = 0; j <nums.size() - 1; j++){
                if(nums[j] < nums[i]){
                    swap(nums[j],nums[i]);
                }
            }
        }
        return nums;
    }
};

//尝试一下双指针的做法吧
#include<bits/stdc++.h>
using namespace std;

/*class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int val = 0;int ji = 0;
        for(int slow = 0; slow < nums.size(); slow++){
            val = nums[slow];
            for(int fast = slow + 1; fast < nums.size(); fast++){
                if(nums[fast]*nums[fast] < nums[slow]*nums[slow]){
                    ji = fast;
                }
            }
            nums[slow] = nums[ji];
            nums[ji] = val;
            nums[slow] = nums[slow] * nums[slow];
        } 
        return nums;
    }
};
操！！！失败了！！！
*/

//我来弥补你的遗憾啦！现在成功啦，不过也经历了痛苦的DBUG
#include <vector>
#include <algorithm>
using namespace std;

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;){
            if(A[i]*A[i] < A[j]*A[j]) {
                result[k] = A[j]*A[j];
                j--;       k--;
            }
            else{
                result[k] = A[i]*A[i];
                i++;       k--;
            }
        }
        return result;
    }
};

part2：

209.长度最小的子数组 

个人思路时间超限了（18/21）

// 18/20 时间超限
#include <vector>
#include <iostream>
using namespace std;

int sum(vector<int> &nums, int fast, int slow)
{
    int he = 0;
    while (fast >= slow)
    {
        he += nums[slow];
        slow++;
    }
    return he;
}

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

int main(){
    vector<int> num = {1,3,1,2,4,3};
    cout << minSubArrayLen(20,num) << endl;
    return 0; 
}

看视频后的进阶版

#include<bits/stdc++.h>
using namespace std;

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
         int i = 0;int sum = 0;int resoult = -1;//末尾指针（快指针）
         for(int j = 0;j < nums.size();j++){
            sum += nums[j];
            while(sum >= target){
                int subl = j - i + 1;
                resoult = resoult < subl ? resoult : subl;
                sum = sum - nums[i++];
            }
         }
         return resoult == -1 ? 0:resoult;
    }
};

part3：

59.螺旋矩阵

#include <vector>
using namespace std;

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        int startx = 0,starty = 0;//起始位置
        int i = 0,j = 0;//遍历时的运动坐标
        int offset = 1;//遍历转圈边界变化
        int count = 1;//遍历中的数字填充
        int loop = n/2;
        //所需的数据定义
        vector<vector<int>> a(n,vector<int>(n,0));

        while (loop--)
        {
            for(j = starty;j < n - offset; j++){
                a[startx][j] = count++;
            }
            for(i = startx; i < n - offset; i++){
                a[i][j] = count++;
            }
            for(;j > starty; j--){
                a[i][j] = count++;
            }
            for(;i > startx; i--){
                a[i][j] = count++;
            }
            startx++;   starty++;  offset++;  
        }
        
        if(n % 2 == 1){
            a[i][j] = count;
        }
        
        return a;
    }
};

四、总结心得

学习了滑动窗口双指针，感觉这个很重要，感觉每一次的条件判断是最关键的，“slow”什么时候移动。螺旋矩阵的话有了思路，有了循环不变量就变得简单了，一遍AC。