代码随想录day2 | 有序数组的平方 长度最小的子数组 螺旋矩阵II

题目一

977. 有序数组的平方 - 力扣（LeetCode）

我的思路

先判断第一个数是不是负数 

如果是负数，则对原数组中各数的绝对值进行排序。

排序方法：找到第一个不为负的数，设置指针B，这个位置往右视为一个有序正数数组，往左是有序负数数组，负数数组中的数取绝对值。指针B左边一个位置设置指针A，于是从中间往两边遍历，用二路归并的排序方法合并两数组为一个有序数组。

之后对数组平方。

（有更精简的方法）

代码

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> new_nums;
        int i = 0;
        if (nums[0] < 0) {
            int A，B;
            for (i = 0; i < nums.size(); i++) 
                if (nums[i] > 0) 
                    break;
            B = i;
            A = i - 1;

            while (A >= 0 && B<nums.size()) {
                if (abs(nums[A]) <= nums[B]) {
                    new_nums.push_back(nums[A]);
                    A--;
                }
                else {
                    new_nums.push_back(nums[B]);
                    B++;
                }
            }

            while (A >= 0) {
                new_nums.push_back(nums[A]);
                A--;
            }

            while (B < nums.size()) {
                new_nums.push_back(nums[B]);
                B++;
            }
            for (i = 0; i < nums.size(); i++) 
                new_nums[i] = new_nums[i] * new_nums[i];
        }
        else 
            for (i = 0; i < nums.size(); i++)
                new_nums.push_back(nums[i] * nums[i]);
        return new_nums;
    }
};

自己写的bug以及解决

1.while循环的终止条件搞错了导致访问了错误的位置

 

错误版：

 while (B <= nums.size()) {
    ...
 }

修改：

 while (B < nums.size()) {
    ...
 }

看了讲解后的思考

1. 暴力排序：排序过程可以直接用排序函数实现。

思路：先平方，后直接用排序函数排序

代码：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        for (int i = 0; i < A.size(); i++) {
            A[i] *= A[i];
        }
        sort(A.begin(), A.end()); // 快速排序
        return A;
    }
};

2.思路二

对我的思路的一个更优化的方法。

双指针法

原先我是从里向外走，这还需要去找第一个非负数，然后从小到大排。其实可以直接从外向里，从大到小排，数组平方最大值只可能在两端。

具体思路：

定义两个指针分别指向数组两端，再定义一个和传进来的数组一样长的新数组result。

循环n次，每次比较两端两指针所指的数的平方的大小，选最大，从后往前填入result。

思路二代码

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--;
            }
            else {
                result[k--] = nums[i] * nums[i];
                i++;
            }
        }
            return result;
    }
};

题目二

我的思路

暴力法

遍历数组，记录以各数字作为第一个数时，符合条件的序列长度，取最小长度。用两个for循环实现

以某一个数字为开头的序列，如果加完剩下的数之后，仍然达不到target，即可不用再往后遍历；

（这个方法提交会超时，但我想不到好的了）

代码

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int i, j;
        int count, mark;
        int sum = 0;
        //如果全部数之和还小于目标值，返回0，否则令count的值为数组长度n
        for (i = 0; i < nums.size(); i++) {
            sum += nums[i];
        }
        if (sum < target)
            return 0;
        else count = nums.size();
        //遍历，找最短子序列
        for (i = 0; i < nums.size(); i++) {
            sum = 0;
            for (j = i; j < nums.size(); j++) {
                sum += nums[j];
                if (sum >= target) {
                    mark = j - i + 1;
                    count = mark < count ? mark : count;
                    break;
                }
                //遍历到某数为起点时时，如果剩余的数全部加起来仍不满足条件，则可返回结果了
                if (j == nums.size() && sum < target)
                    return count;
            }
        }
        return count;
    }
};

自己写的bug以及解决

1. bug:输出恒为1。

检查后发现是没有初始化序列长度

看解析后的思考

1.思路二

双指针法，只用一个for循环时间复杂度降为O(n)

设置两个指针，起始指针A和终止指针B，B用于遍历数组，A用于根据子序列之和调整缩短子序列长度。

初始化A、B指向第一个数。

B后移，A不动，直至子数组数字之和大于目标值；A后移，B不动，直至子数组数字之和小于目标值。到A指向最后一个数字且子数组数字之和小于目标值时终止。

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

题目三

我的思路

二阶矩阵，按要求控制行标和列标按存储即可。

列了个五阶矩阵找一下规律

打算一个for循坏套四个for循环，外层for循环控制i和j，里层填数。

看成是正方形套正方形，一层一层往里填，比如这个，就要填三个正方形

当n为奇数时，有一个最中心的数；n为偶数时，最里面则是一个小正方形。所以在循环之外再加一个判断，当n为奇数时，还要额外填充最中心的数。

代码

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

自己写遇到的bug及解决

1. 当n>=4时输出都不对

错误：外层for循环，只修改了i,没有修改变量j

for (i = 0, j = n - 1 - i; i < n / 2; i++) {
   ...
}

修改：

for (i = 0, j = n - 1 - i; i < n / 2; i++，j--) {
  ...
}

看解析后的思考

1.一样的思路，一个正方形一个正方形的填，可以修改一下填充方式，让代码规整一些。填充一个正方形时，每次填充（边长-1）个。（即让4个for循环都是左闭右开）

vector<vector<int>> generateMatrix(int n) {
    vector<vector<int>> matrix(n, vector<int>(n));
    int count = 1;
    int i, j;
    for (i = 0; i < n / 2; i++) {
        j = n - 1 - i;
        for (int k = i; k < j; k++)
            matrix[i][k] = count++;
        for (int k = i; k < j; k++)
            matrix[k][j] = count++;
        for (int k = j; k > i; k--)
            matrix[j][k] = count++;
        for (int k = j; k > i; k--)
            matrix[k][i] = count++;
    }
    if (n % 2 != 0)
        matrix[n / 2][n / 2] = count;
    return matrix;
}