day02打卡

day02打卡

977. 有序数组的平方

时间复杂度：O(N)，空间复杂度：O(N)。

第一想法：直接平方后，进行排序，但是时间复杂度为O(N*longN)。

困难：没想到时间复杂度为O(N)的解决方法

看了题解后，先找到正数和负数的分界线，再进行归并。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        //先找到正数和负数的分界线
        int index = 0;
        for(int i = 0; i < nums.size(); i++)
        {
            if(nums[i] < 0) index = i;
            else break;
        }
        //进行归并排序
        int i = index, j = index + 1, n = nums.size();
        vector<int> ret;
        while(i >= 0 || j < n)
        {
            //如果i小于0，只填j
            if(i < 0)
            {
                ret.push_back(nums[j] * nums[j]);
                j++;
            }
            else if(j == n)//如果j等于n只填i
            {
                ret.push_back(nums[i] * nums[i]);
                i--;
            }
            else if(nums[i] * nums[i] > nums[j] * nums[j])
            {
                ret.push_back(nums[j] * nums[j]);
                j++;
            }
            else
            {
                ret.push_back(nums[i] * nums[i]);
                i--;
            }
        }
        return ret;
    }
};

209. 长度最小的子数组

时间复杂度：O(N)，空间复杂度：O(1)

第一想法：滑动窗口

困难：没能够实现

看了题解：用sum记录窗口内的数的大小，一大于等于就记录长度，长度取ret和right - left - 1之间，更小的那个

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int sum = 0, ret = INT_MAX;
        for(int left = 0, right = 0; right < nums.size(); right++)
        {
            //进窗口
            sum += nums[right];
            while(sum >= target)
            {
                //更新结果
                ret = min(right - left + 1, ret);
                //出窗口
                sum -= nums[left++];
            }
        }
        return ret == INT_MAX ? 0 : ret;
    }
};

59. 螺旋矩阵 II

时间复杂度：O(N^2)，空间复杂度：O(N*N)

第一想法：模拟填数的过程

困难：代码实现上还是有困难

看了题解之后：通过每一层模拟完后削去一层，直到start == n * n。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> mat(n, vector<int>(n));
        int top = 0, bottom = n - 1, left = 0, right = n - 1;
        int start = 1;
        while(start <= n * n)
        {
            //left->right
            for(int i = left; i <= right; i++)  mat[top][i] = start++;
            top++;
            //top->bottom
            for(int i = top; i <= bottom; i++)  mat[i][right] = start++;
            right--;
            //right->left
            for(int i = right; i >= left; i--) mat[bottom][i] = start++;
            bottom--;
            //bottom->top
            for(int i = bottom; i >= top; i--) mat[i][left] = start++;
            left++;
        }
        return mat;
    }
};