977.有序数组的平方
一种直观的思想是暴力解法,将每个位置遍历然后平方后,再整体排序一次。时间复杂度O(n + nlog n)
另一种也可以用到双指针。注意题干条件:nums数组为非递减顺序
主打一个关键点:数组平方的最大值不是在最左边,就是在最右边,不可能在中间
其实很容易理解,平方最大嘛,相当于绝对值最大,要么就是负得最多,要么就是正得最多
怎么利用这个特点呢?双指针法
一个指针指向数组最左端,一个指针指向数组最右端,然后取出最大的平方项,放在结果里,然后看情况移动这两个指针,缩减平方后最大的元素可能出现的区间
代码如下
class Solution {
public:
vector<int> sortedSquares(vector<int>& nums) {
int leftIndex = 0, rightIndex = nums.size() - 1; //指向两端的指针
vector<int> res(nums.size());
int resIndex = nums.size() - 1; //指向结果数组待填充的位置
while (leftIndex <= rightIndex) { //注意<=,因为是左闭右闭方式描述区间
if (nums[leftIndex] * nums[leftIndex] <= nums[rightIndex] * nums[rightIndex])
{
res[resIndex] = nums[rightIndex] * nums[rightIndex];
resIndex--;
rightIndex--;
} else {
res[resIndex] = nums[leftIndex] * nums[leftIndex];
resIndex--;
leftIndex++;
}
}
return res;
}
};
有下面几个细节需要注意
- 初始化两个指针leftIndex为0,rightIndex为size - 1,能够看出我们描述nums中元素区间用的是左闭右闭方式[leftIndex, rightIndex]
- while条件和上一篇二分搜索同理,当平方后最大的元素可能出现的区间还有元素时,就要一直循环,故while (leftIndex <= rightIndex),注意等于时也是有元素的,需要进循环。
- resIndex的作用:指向结果数组下一个需要被填充的位置
当然,这道题能够在上面代码上做如下简化,但是思路是一样的
class Solution {
public:
vector<int> sortedSquares(vector<int>& A) {
int k = A.size() - 1; //指向结果数组下一个需要被填充的位置
vector<int> result(A.size(), 0);
//左指针i,右指针j
for (int i = 0, j = A.size() - 1; i <= j;) { // 注意这里要i <= j,因为左闭右闭
if (A[i] * A[i] < A[j] * A[j]) {
result[k--] = A[j] * A[j];
j--;
}
else {
result[k--] = A[i] * A[i];
i++;
}
}
return result;
}
};
可以看出这道题和Day1中多少有点儿技巧上的共性,二分搜索通过移动左右指针缩减待搜索元素可能出现的区间,本题通过左右指针缩减平方后最大元素可能出现的区间;移除元素中用指针指向新数组下一个需要更新(被填充)的位置,这里也用到了。所以关键还是那么几点:确定区间的描述方式、定循环条件、如何缩减区间、记得维护指针指向结果数组下一个需更新的位置
209.长度最小的子数组
直观想法:暴力法,两个for循环,第一个for循环遍历子序列的起始,第二个for循环遍历子序列的末尾,从而找到所有的子序列,然后对每个子序列都看看总和,算算长度,看是不是最小
显然,复杂度O(n^2),很呆,不妥
想到使用滑动窗口法
滑动窗口法是什么:一图以蔽之
简单来说,就是维护两个指针,分别指向子序列的起始位置和终止位置,通过不断调节起始位置和终止位置,得到我们想要的结果
形象一点儿的描述方式 :可以想象一下毛毛虫在爬行
毛毛虫的头部代表了子序列的终止位置,毛毛虫的尾部代表子序列的起始位置。毛毛虫身体盖住的范围就是这个“窗口”。可以从图看出:通过不断调节毛毛虫的头部位置和尾部位置来实现窗口的变化。
这道题中主要需要确定以下几点
- 什么时候在右侧扩大窗口(毛毛虫头部向右伸)
- 什么时候在左侧缩小窗口 (毛毛虫尾部向右缩)
这道题中,当窗口内元素和小于target的时候,在右侧扩大窗口,当窗口内元素和大于等于target的时候,在左侧缩小窗口
看代码如下
class Solution {
public:
int minSubArrayLen(int target, vector<int>& nums) {
int slow = 0, fast = 0;
int sum = 0;
int res = INT32_MAX; //窗口最小长度
int len = 0;
while (fast < nums.size()) {
sum += nums[fast++];
len++;
while (sum >= target) {
res = res < len ? res : len;
sum -= nums[slow++];
len--;
}
}
return res == INT32_MAX ? 0 : res;
}
};
slow是窗口左侧,fast为窗口右侧,[slow, fast]代表窗口元素。外层循环while中当窗口右侧没有到数组最右侧的时候,就可以一直向右扩大窗口(相当于毛毛虫头部没走到尽头)。扩大窗口需要做一系列操作来维护窗口内元素和以及窗口长度。
然后,当某个时刻,窗口内元素大于等于target了,表明此时窗口所覆盖序列为一个满足和>=target的序列,此时应将该窗口的长度与之前窗口最小长度比,看看此时这个序列的长度是不是更小,如果更小的话需要更新最小长度。接下来,需要在左侧缩减窗口大小,缩小窗口同样需要做一系列操作来维护窗口内元素和以及窗口长度。注意内层需要用while表示“不断缩减长度直到窗口内的元素和又重新小于target”
另一种写法
class Solution {
public:
int minSubArrayLen(int s, vector<int>& nums) {
int result = INT32_MAX;
int sum = 0; // 滑动窗口数值之和
int i = 0; // 滑动窗口起始位置
int subLength = 0; // 滑动窗口的长度
for (int j = 0; j < nums.size(); j++) {
sum += nums[j];
// 注意这里使用while,每次更新 i(起始位置),并不断比较子序列是否符合条件
while (sum >= s) {
subLength = (j - i + 1); // 取子序列的长度
result = result < subLength ? result : subLength;
sum -= nums[i++]; // 这里体现出滑动窗口的精髓之处,不断变更i(子序列的起始位置)
}
}
// 如果result没有被赋值的话,就返回0,说明没有符合条件的子序列
return result == INT32_MAX ? 0 : result;
}
};
注意这两种写法的共同点如下
- return需要考虑没有符合条件的子序列的情况,此时进不了内层while循环
- 外层循环都控制的窗口右侧扩大,内层循环才控制窗口左侧缩小
这个很关键,因为看毛毛虫爬行的逻辑是“先不断伸长,再不断缩短”
59.螺旋矩阵II
这道题不涉及算法,就是模拟过程。硬做
主打一个考察写代码的水平
class Solution {
public:
vector<vector<int>> generateMatrix(int n) {
int x = 0, y = 0; //初始位置(x, y)
enum {right, down, left, up} direction = right; //一开始设定方向往右
vector<vector<int> > result(n, vector<int>(n, 0)); //生成一个n*n的全0矩阵
for (int i = 1; i <= n * n; i++) //i为每个位置待填充的元素,最多填充到n^2,因此循环到<=n*n
{
result[x][y] = i; //填充完成,接下来准备沿着既定方向去到下一个待填充的位置
//既定方向向右
if (direction == right)
{
if ((y + 1) < n && result[x][y + 1] == 0) //如果还没有走到矩阵右侧尽头且右边一个位置还没被填充过,那么这次就往右走
{
++y;
continue;
}
else
{ //沿这方向走到头了,再看看能不能向下走
direction = down;
}
}
//既定方向向下
if (direction == down)
{
if ((x + 1) < n && result[x + 1][y] == 0) //如果还没有走到矩阵下侧尽头且下边一个位置还没被填充过,那么这次就往下走
{
++x;
continue;
}
else
{ //沿这个方向走到头了,再看看能不能向左走
direction = left;
}
}
//既定方向向左
if (direction == left)
{
if ((y - 1) >= 0 && result[x][y - 1] == 0)
{
--y;
continue;
}
else
{
direction = up;
}
}
//既定方向向上
if (direction == up)
{
if ((x - 1) >= 0 && result[x - 1][y] == 0)
{
--x;
continue;
}
else
{ //向上走不了了,那么不用看了,该往右走了,并走出一步(别忘了要实现选择方向并前进)
direction = right;
if ((y + 1) < n && result[x][y + 1] == 0)
y++;
}
}
}
return result;
}
};
将整个过程模拟成:到了一个位置,填充数字,然后沿着既定方向前进,前进不了则选择另一个方向再试试能不能前进,能的话就前进。
选择方向需要分别看看能不能向右走,能不能向下走,能不能向左走,能不能向右走(顺时针)
注意:在通过索引访问数组的时候,判断越界一定要在访问前!(力扣很多错误就是因为这样导致的)即
if ((y + 1) < n && result[x][y + 1] == 0)
逻辑运算符左右两侧表达式顺序不能换
位置用坐标(x, y)描述。这个坐标是以左上角为原点的
回顾总结
除了509是一道硬做题,其他主要还是靠通过维护双指针来维护区间的手法