数组有序数组平方长度最小子数组螺旋矩阵II

最新推荐文章于 2024-07-25 20:49:11 发布

暁_

最新推荐文章于 2024-07-25 20:49:11 发布

阅读量1k

点赞数

文章标签：矩阵算法 leetcode

本文链接：https://blog.csdn.net/m0_59425585/article/details/134361417

版权

有序数组的平方

题目：Leetcode977

解法一：暴力解法

思路：求出所有数的平方后，再排序

时间复杂度： O(n + nlogn)

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

解法二：双指针法

思路：有正有负的有序数组，平方后最大数一定在两端，使用双指针分别指向起始位置和终止位置，进行比较，结果存放入新数组中。

时间复杂度：O(n)

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int index = nums.size() - 1;//新数组最大索引
        vector<int> result;//新数组，存放结果
        result.resize(nums.size());
        //i指向起始位置，j指向终止位置，比较元素的平方，把更大的结果放入新数组，依次向前填充
        for(int i = 0, j = nums.size() - 1; i <= j; ) { //注意这里要i <= j，因为最后要处理两个元素
            if(nums[i] * nums[i] > nums[j] * nums[j]) {
                result[index--] = nums[i] * nums[i];
                i++;
            }
            else {
                result[index--] = nums[j] * nums[j];
                j--;
            }
        }
        return result;
    }
};

长度最小的子数组

题目：Leetcode209

解法一：暴力解法（超出时间限制）

两个for循环穷举寻找，时间复杂度O(n^2)。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int minLen = INT32_MAX;//记录最小长度，只有初始值为最大值，才能不断更新最小值
        int curLen = 0;//记录当前子数组长度
        int sum = 0;//记录子数组元素之和
        //i记录起始位置，j记录终止位置
        for(int i = 0; i < nums.size(); i++) {
            sum = 0;
            for(int j = i; j < nums.size(); j++) {
                sum += nums[j];
                if(sum >= target) {
                    curLen = j - i + 1;
                    minLen = minLen < curLen ? minLen : curLen;//更新最小长度
                    break;
                }  
            }
        }
        return minLen == INT32_MAX ? 0 : minLen;
    }
};

解法二：滑动窗口

滑动窗口：不断更新子序列的起始位置和终止位置，直到找到符合条件的结果。

思路：1个for循环，如果表示起始位置，那又变成了暴力解法，因此一个for循环表示的是滑动窗口的终止位置。时间复杂度为O(n)。

窗口内是什么？
- 满足其和 ≥ target 的长度最小的连续子数组
起始位置如何移动？
- 当当前窗口内元素和 >target，移动起始位置，窗口缩小
终止位置如何移动？
- 窗口的结束位置就是遍历数组的指针，也就是for循环里的索引

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int minLen = INT32_MAX;//只有初始值为最大值，才能不断更新最小值
        int curLen = 0;
        int sum = 0;
        int i = 0;//起始位置
        for(int j = 0; j < nums.size(); j++) {  //终止位置向后移动直到总和大于target
            sum += nums[j];
            while(sum >= target) {
                curLen = j - i + 1;//记录当前滑动窗口长度
                minLen = minLen < curLen ? minLen : curLen;//更新最小长度
                sum -= nums[i++];//不断变更i（子序列的起始位置）缩小滑动窗口，继续while判断
            }
        }
        return minLen == INT32_MAX ? 0 : minLen;
    }
};

螺旋矩阵II

思路：本题的关键在于对边界的处理方式，要用固定的规则（左闭右开），坚持循环不变量原则。

时间复杂度 O(n^2): 模拟遍历二维矩阵的时间

模拟顺时针画矩阵的过程:

填充上行从左到右
填充右列从上到下
填充下行从右到左
填充左列从下到上

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> matrix(n, vector<int>(n, 0));
        int startx = 0;//定义起始位置横坐标
        int starty = 0;//定义起始位置纵坐标
        int loop = n/2;//定义循环圈数，每一圈处理掉2行/列，所以是n/2
        int offset = 1;//控制每次处理边长度的收缩量
        int count = 1;//要填充进矩阵的值
        int i,j;

        while(loop--) {
            i = startx;
            j = starty;
            // 模拟填充上行从左到右(左闭右开)
            for(j = starty; j < n - offset; j++) {
                matrix[i][j] = count++;
            }
            // 模拟填充右列从上到下(左闭右开)
            for(i = startx; i < n - offset; i++) {
                matrix[i][j] = count++;
            }
            // 模拟填充下行从右到左(左闭右开)
            for( ; j > starty; j--) {
                matrix[i][j] = count++;
            }
            // 模拟填充左列从下到上(左闭右开)
            for( ; i > startx; i--) {
                matrix[i][j] = count++;
            }
            //更新下一圈的起始位置
            startx++;
            starty++;
            //更新下一圈处理边界时的收缩量
            offset++;
        }

        //如果n为奇数，单独处理正中间位置
        if(n%2) {
            matrix[n/2][n/2] = count; 
        }

        return matrix;
    }
};