day2-双指针与循环矩阵-CSDN博客

本文链接：https://blog.csdn.net/weixin_43711012/article/details/139159284

有序数组的平方

思路很快，写的也很快，很简单的双指针法

class Solution
{
public:
    int abs(int a)
    {
        if (a < 0)
        {
            return -a;
        }
        else
        {
            return a;
        }
    }

    vector<int> sortedSquares(vector<int> &nums)
    {
        int length = nums.size();
        int left = 0, right = length - 1;
        vector<int> res = nums;
        int index = right;
        while (left <= right)
        {
            // 大值在右
            if (abs(nums[right]) >= abs(nums[left]))
            {
                // nums[right] = nums[right] * nums[right];
                res[index--] = nums[right] * nums[right];
                right--;
            }
            // 大值在左
            else
            {
                res[index--] = nums[left] * nums[left];
                left++;
            }
        }
        return res;
    }
};

问题

一开始想在原地解决问题，后面发现不可以（具体来说，在数组中不可行，因为会产生大量移位操作，在链表中是可行的）

长度最小子数组

class Solution
{
public:
    int minSubArrayLen(int target, vector<int> &nums)
    {
        int res = INT_MAX;
        int length = nums.size();
        int sum = 0;
        // 遍历终止位置
        int left = 0;
        for (int right = 0; right < length; right++)
        {
            sum += nums[right];
            while (left <= right && sum >= target)
            {
                res = min(res, right - left + 1);
                sum -= nums[left];
                left++;
            }
        }
        return res == INT_MAX ? 0 : res;
    }
};

思路很快就有了，但是具体操作出了问题

问题

因为很笨的每一个循环都遍历下标重新求和，导致时间超出了限制
sum变化时对边界的处理还不够熟练，右边界变化和sum增加不一定能够同时成立，这一点疏忽了
相比卡哥的实现，我的code实在不够简洁明了
有时候想的太多，总觉得可以再省略，应该循序渐进

螺旋矩阵

class Solution
{
public:
    vector<vector<int>> generateMatrix(int n)
    {
        vector<vector<int>> res(n);
        for (int i = 0; i < n; i++)
        {
            res[i].resize(n);
        }
        int line_begin = 0, col_begin = 0;
        int offset = 1;
        int count = 1;

        int num = n / 2;
        while (num > 0)
        {
            // 定义起点
            int line_index = line_begin, col_index = col_begin;
            // 向右

            // 妙处在于，col_index <n-offset，则循环结束后，col_index的值恰好等于n-offset，也就是下一条边的起点，无需额外回退操作。
            // 当然这也是因为“一个顶点一个边”的均分策略的完美。
            for (col_index = col_begin; col_index <n-offset; col_index++)
            {
                res[line_index][col_index] = count++;
            }
            // 向下
            for (line_index = line_begin; line_index < n-offset; line_index++)
            {
                res[line_index][col_index] = count++;
            }
            // 向左
            for (; col_index > col_begin; col_index--)
            {
                res[line_index][col_index] = count++;
            }
            // 向上
            for (; line_index > line_begin; line_index--)
            {
                res[line_index][col_index] = count++;
            }

            // 内部变量更新
            line_begin++;
            col_begin++;
            offset++;
            // 循环量更新
            num--;
        }

        if (n % 2)
        {
            res[n / 2][n / 2] = n*n;
        }
        return res;
    }
};