有序数组的平方
给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
示例 1：
输入：nums = [-4,-1,0,3,10] 输出：[0,1,9,16,100] 解释：平方后，数组变为 [16,1,0,9,100] 排序后，数组变为 [0,1,9,16,100]
示例 2：
输入：nums = [-7,-3,2,3,11] 输出：[4,9,9,49,121]
思路
首先，最容易想到的就是暴力的解法，也就是先遍历一遍数组，将其挨个平方，然后再进行排序，比较简单。优化的话我们可以考虑双指针法，不难发现，平方后最大的数是在给定数组的最左侧和最右侧，所以我们可以在两边定义两个指针，通过比较，获得平方后的最大数，将其存放在一个新的数组的最后面（新数组和原数组大小一样），然后将平方后最大数的位置往前或往后移，这取决于平方后最大数是在前面还是在后面，按上面的步骤依次进行，得到的新数组就是符合条件的了。
暴力解法
vector<int> sortedSquares(vector<int>& nums) {
for(int i = 0; i < nums.size(); i++){
nums[i] = pow(nums[i], 2);
}
sort(nums.begin(), nums.end());
return nums;
}遍历一遍数组，将其挨个平方，然后再进行排序，比较简单。时间复杂度是(n + nlogn)，sort函数的底层是内省式排序以及插入排序，感兴趣的可以自行百度。
双指针法
vector<int> sortedSquares(vector<int>& nums) {
vector<int> newNums(nums.size());
int k = nums.size() - 1;
int i = 0, j = nums.size() -1;
while(i <= j){
if (nums[i] * nums[i] > nums[j] * nums[j]) {
newNums[k--] = nums[i] * nums[i];
i++;
}
else {
newNums[k--] = nums[j] * nums[j];
j--;
}
}
return newNums;
}首先，我们需要的是一个和原数组大小一样的新数组，所以利用vetor构造函数直接生成一个。我们还需要指向两边的两个指针 i 和 j 以及指向新数组的末尾的指针k（因为我们是从两边向内找，所以找出来的是从大到小的，我们想要新数组从小到大的话就需要从他的末尾插入元素）。而循环的判断条件为什么不能是 i < j 呢？因为当 i == j 时，如果我们写的循环判断条件是 i < j ，那么就会漏掉一个元素，所以循环判定条件为 i <= j 。在 if 判断中，如果前面的元素平方后比较大，那么将其放入新数组的末尾并且新数组的末尾指针 k-- ，然后原数组中的指向最前面的指针 i++ 即可，下面的 else 同理。至于两个数平方后相等的情况，放哪个都可以，所以直接包含在 else 内了。最后返回新数组即可。
长度最小的子数组
给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
示例 1：
输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
示例 2：
输入：target = 4, nums = [1,4,4] 输出：1
示例 3：
输入：target = 11, nums = [1,1,1,1,1,1,1,1] 输出：0
思路
暴力解法
int minSubArrayLen(int target, vector<int>& nums) {
int resultLenth = INT_MAX;
for(int i = 0;i < nums.size(); i++){
int sum = 0;
for(int j = i; j < nums.size(); j++){
sum += nums[j];
if(sum >= target){
int subLenth = j - i + 1;
resultLenth = resultLenth > subLenth ? subLenth : resultLenth;
break;
}
}
}
return resultLenth == INT_MAX ? 0 : resultLenth;
}这个题是一道在力扣上中等难度的题，暴力的解法是定义一个 resultLenth，用来表示目前寻找到的最小长度，因为我们要找最小，所以我们需要定义一个最大值 INT_MAX ，这样如果找到了符合条件的长度，和最大值比较都会小，从而更新 resultLenth 。然后用两个for，外部循环 i 在起始位置不动，内部循环 j 往后寻找，过程中一直累计区间 [i, j] 的和，用sum来记录，直到此区间内的和 sum > target 为止，算出这个区间的长度并和 resultLenth 比较，resultLenth 更新为更小的那个，然后 break 跳出（因为我们要找的是最小的，之后的肯定都会比目前寻找到的大，都是无用功，所以直接跳出就可以了，这个break很容易忘，需要注意）。返回的时候注意如果 target 很大，没有找到相应的区间，要返回0，所以直接看resultLenth有没有被修改即可，没被修改就直接返回0，被修改就返回修改的值。
滑动窗口
优化的话我们可以采用滑动窗口的方法，滑动窗口首先要有两个指针，还是指向起始位置和终止位置，但是用一个 for 就可以不断调节两个指针的位置。代码如下：
int minSubArrayLen(int target, vector<int>& nums) {
int resultLenth = INT_MAX;
int sum = 0;
for (int i = 0, j = 0; j < nums.size(); j++){
sum += nums[j];
while (sum >= target){
int subLenth = j - i + 1;
resultLenth = subLenth < resultLenth ? subLenth : resultLenth;
sum -= nums[i++];
}
}
return resultLenth == INT_MAX ? 0 : resultLenth;
}我们来分析一下这个代码，这样才会对代码有更深的印象，也就不容易遗忘。首先，resultLenth的定义和暴力解法一样，这里不再赘述。sum用来表示从起始位置到终止位置的和，在循环中，定义了 i 和 j 我们需要明白他们分别表示什么， i 表示的是起始位置，j 表示的是终止位置，为什么我们循环的索引是终止位置呢？如果我们循环的索引是起始位置，那么怎么保证终止位置的移动呢？这样还是会陷入到暴力解法之中，时间复杂度还是。所以我们需要表示的是终止位置，但有的朋友会问，起始位置的移动怎么办呢？随着终止位置的不断移动，我们会找到在区间 [i, j] 之间的和大于等于 target 的情况，也就是 sum >= target 的情况，这时候我们就需要移动起始位置来保证这个区间长度的最小，有的朋友可能会比较疑惑，为什么我们判断 sum >= target 是用的while而不是 if 呢，举个例子，假设给定的 nums 为 [1, 2, 3, 4, 9999]，target 为1000那么当我们的终止位置移动到9999这个位置的时候才会计算区间 [i, j] 之间的和，这时候如果用的是 if ，那么我们的起始位置 i 只能移动一次，也就是到 2 的位置，但是应该移动到 9999 的位置才对，所以这时候就应该是一个循环来不断地把起始位置向前移动。在 while 循环的内部，计算出起始位置到终止位置的长度并且和 resultLenth 比较是比较常规的，需要注意的是因为我们起始位置是一个动态调节的过程，而 sum 表示的是区间 [i, j] 的和，所以在起始位置 i 不断向前移动的过程中，相应的sum应该减去 num[i] ，之后才是起始位置向前移动一位（这个很容易忘掉！！）。返回的时候注意如果 target 很大，没有找到相应的区间，要返回0，所以直接看resultLenth有没有被修改即可，没被修改就直接返回0，被修改就返回修改的值。
螺旋矩阵II
给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。
示例 1：
输入：n = 3 输出：[[1,2,3],[8,9,4],[7,6,5]]
示例 2：
输入：n = 1 输出：[[1]]
思路
对于这道题，其实没什么算法，就是模拟过程，但是怎么样遍历才能螺旋转圈呢？我们可以定义四个边界，分别是 left, right, top, bottom ，分别表示左右上下四个边界，然后定义一个自加的变量count，按照从左往右，从上到下，从右到左，从下到上的顺序来填充矩阵，光说可能大家看的有些迷糊，我们来结合代码分析。
vector<vector<int>> generateMatrix(int n) {
vector<vector<int>> res(n, vector<int>(n,0));
int l = 0, r = n - 1, t = 0, b = n - 1;
int count = 1, tar = n * n;
while(count <= tar){
for(int i = l; i <= r; i++){
res[t][i] = count++;
}
t++;
for(int i = t; i <= b; i++){
res[i][r] = count++;
}
r--;
for(int i = r; i >= l; i--){
res[b][i] = count++;
}
b--;
for(int i = b; i >= t; i--){
res[i][l] = count++;
}
l++;
}
return res;
}count表示的是我们每次要填入的数字，每次填入后自加，tar 表示的是我们要填多少次数字（也就是n * n），在while循环中，填 <= 而不是 < 原因是解决 n 为奇数时中心数字无法填入的问题，按照从左往右，从上到下，从右到左，从下到上的顺序来填充矩阵。我们挨个来看，首先是从左到右从左边界开始，到右边界，也就是从 l 到 r ，是我们行不动，列在动，也就是我们的 i 控制的是列，所以数组的纵坐标是 i ，因为我们填充的是上面的一行，所以我们的横坐标是代表上边界的 t 。然后，因为我们填充了最上面一行，所以我们的上边界应该 +1 ，也就是往内缩了一行，这样就不会重复访问数字3这个位置了。从上到下，也就是从 t 到 b ，行在动，列不动，所以 i 控制的是我们的行，所以数组的横坐标为 i ，因为我们填充的是右面的一行，所以我们的纵坐标为 r 。
同理，我们的右边界也应该往内缩一行（注意！右边界往内缩是 -- 而不是 ++）。从右到左，也就是从 r 到 l （注意！从右到左 i 是 -- 而不是 ++），行不动，列在动，那么 i 控制的是我们的列，所以数组的纵坐标为 i ，因为我们填充的是下面这一行，所以数组的横坐标为 b 。同理，我们的下边界也向内缩（注意！下边界往内缩是 -- 而不是 ++）。从下往上，也就是从 b 到 t （注意！从下到上 i 是 -- 而不是 ++），i 控制的是我们的的行，所以数组的横坐标为 i ，因为我们填充的是左面这一行，所以数组的纵坐标为 l 。同理左边界往内缩一行，也就是 +1。
这道题我认为需要重点注意的是以下三点：
- 明白 i 控制的是什么，行还是列？对应横坐标或者纵坐标也就确定了。那么另一个横纵坐标取决于你填充的是上面？下面？左面？右面？填对应的边界表示的变量。
- 明白自己的变量 i 是从哪到哪？是 ++ 还是 -- ？从左到右和从上到下都是 i++，从右到左和从下到上都是 i--。
- 边界更新，也就是边界向内缩的时候搞清楚是 ++ 还是 -- 。
343
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
