刷题记录day2

leetcode59螺旋矩阵II

        思路：一开始我想的是在循环体里限制边界最外层每次到n-1就停下，最后发现行和列记录的值为2和1，并不是第二层起始的位置，因此导致结果不正确，最后参考了官方的题解。又重新更正了一遍。

        划定了top、bottom、left、right四个边界，当触及边界就停下并且更新边界值。一层一层的进行。

#include <iostream>
#include <vector>

using namespace std;

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {\
        //分别记录四个边界
        int t = 0;      // top
        int b = n-1;    // bottom
        int l = 0;      // left
        int r = n-1;    // right
        vector<vector<int>> ans(n,vector<int>(n));
        int k=1;
        while(k<=n*n){
            for(int i=l;i<=r;++i,++k) ans[t][i] = k;
            ++t;
            for(int i=t;i<=b;++i,++k) ans[i][r] = k;
            --r;
            for(int i=r;i>=l;--i,++k) ans[b][i] = k;
            --b;
            for(int i=b;i>=t;--i,++k) ans[i][l] = k;
            ++l;
        }
        return ans;
    }
};

leetcode209长度最小的子数组

        思路：使用了滑动窗口的办法，记录窗口左右边界，当总和小于target时right就加一，然后计算新的总和，当和大于或者等于target时就更新长度ans,也就是我们要看在窗口内的子数组的和是否大于等于target当小于时就继续放入新的数，大于或者等于就更新长度并且将左侧边界加一。

#include <iostream>
#include <vector>
using namespace std;

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int left = 0, right = 0;    //记录窗口左右边界
        int ans = INT_MAX;  //记录最小长度
        int n = nums.size();
        if(n == 0) {
            return 0;
        }
        int sum = 0;    //记录滑动窗口内的和
        while(right < n) {
            sum +=  nums[right];
            while(sum >= target) {  //当和大于等于target记录ans
                ans = min(ans, right - left + 1);
                sum -= nums[left];
                left++;
            }
            right++;
        }
        return ans == INT_MAX ? 0 : ans;    //可能存在找不到但是返回值应该是0
    }
};

 leetcode977有序数组的平方

        思路：一个非递减的有序数组也就是递增数组（包含0）求其平方以后的新数组，我选择利用sort（）函数，先将数组的每个数都进行平方然后调用sort（）进行排序。

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {  //先全部平方在排序（算是有点小偷懒）
        int n = nums.size();
        for(int i = 0; i < n; i++) {
            nums[i] = nums[i] * nums[i];
        }
        sort(nums.begin(),nums.end());
        return nums;
    }
};

方法二：双指针法

        思路：先找规律，因为原数组是递增的，所以在正数范围内的数平方以后的顺序也是递增的，负数范围内的数平方以后的顺序则是递减的，因此可以利用双指针法，记录正（包括0）、负分界线。

        然后比较正、负数平方后的大小按照从小到大依次放入新的数组内。（这里搬运一下官方的题解代码）

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n = nums.size();
        int negative = -1;
        for (int i = 0; i < n; ++i) {
            if (nums[i] < 0) {
                negative = i;
            } else {
                break;
            }
        }

        vector<int> ans;
        int i = negative, j = negative + 1;
        while (i >= 0 || j < n) {
            if (i < 0) {
                ans.push_back(nums[j] * nums[j]);
                ++j;
            }
            else if (j == n) {
                ans.push_back(nums[i] * nums[i]);
                --i;
            }
            else if (nums[i] * nums[i] < nums[j] * nums[j]) {
                ans.push_back(nums[i] * nums[i]);
                --i;
            }
            else {
                ans.push_back(nums[j] * nums[j]);
                ++j;
            }
        }

        return ans;
    }
};