代码训练营第二期Day02

代码训练营第二期Day02

一、LeetCode 977.有序数组的平方

力扣题目链接：https://leetcode.cn/problems/squares-of-a-sorted-array/

给你一个按 非递减顺序 排序的整数数组nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
例：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]

第一眼思路：先遍历整个数组，把每个元素平方，再进行排序
冒泡排序：从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个出来。这个数就会从序列
的最右边冒出来

提示用双指针法，仍然没有思路。

关键没有意识到：

1、平方后的数组，最大值只有可能在两端，且这个原则是不会变的

2、双指针法理解不够透彻，不能灵活使用

3、定义一个同样大小的数组，存放结果（用空间换时间）

vector<int> sortedSquares1(vector<int>& nums) {
		for (int i = 0; i < nums.size(); i++)
		{
			nums[i] = pow(nums[i],2);
		}
		//冒泡排序
		for (int j = 0; j < nums.size() - 1; j++)
		{
			for (int k = 0;k < nums.size() - j - 1; k++)
			{
				if (nums[k] > nums[k + 1])
				{
					int temp = 0;
					temp = nums[k + 1];
					nums[k + 1] = nums[k];
					nums[k] = temp;
				}
			}		
		}
		return nums;
}

	//双指针法***O(n)
	vector<int> sortedSquares2(vector<int>& nums) {
		vector<int> result(nums.size(),0);	
		int size = nums.size();
		int i = 0;
		int j = size - 1;
		int k = result.size() - 1;
		for (k = result.size() - 1; k >= 0; k--)
		{
			if ((pow(nums[i], 2)) >= (pow(nums[j], 2)))
			{
				result[k] = pow(nums[i], 2);
				i++;
			}
			else // ((pow(nums[i], 2)) < (pow(nums[j], 2)))
			{
				result[k] = pow(nums[j], 2);
				j--;
			}
		}
		return result;
	}

二、LeetCode 209.长度最小的子数组

题目链接：https://leetcode.cn/problems/minimum-size-subarray-sum/

第一眼暴力解法都没有思路，看了文章之后，知道了大概思路：

遍历所有的子数组，寻找符合条件的情况，然后不断更新结果

$理解：暴力解法一般想有没有办法遍历出所有情况，然后和条件比对$

以后至少暴力解法要有思路

滑动窗口其实和双指针思路是差不多的

最重要的思路：

• 用一个for循环来完成两个for循环的工作
• 如果循环里面的变量代表起始位置，其实和暴力解法是没有区别的，故要想如果循环里的变量代表终止位置，如何动态移动起始位置的指针来实现滑动窗口
• 当我们发现起始位置到终止位置之间的集合已经满足条件了，这时再移动起始位置的指针来寻找最小的子数组
• 重点：如何移动起始位置？
  • 终止位置先从0开始，不断移动终止位置，此时区间内元素的和就会不断增大，直到>=target
  • 这时，再通过**while循环（不是if）**来不断移动起始位置的指针，以此筛选出符合条件的最小长度的子数组

感觉自己总是没法跳出暴力解法的怪圈

class Solution {
public:
    //暴力解法
    int minSubArrayLen1(int target, vector<int>& nums) {
        int result = INT32_MAX;     //最终结果
        int sum = 0;        //子数组之和
        int length = 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)
                {
                    length = j - i + 1;
                    result = result > length ? length : result;     //更新结果
                    break;              //找到了之后就直接break，因为继续加元素肯定不是最小长度子数组了
                }
            }
        }
        return result == INT32_MAX ? 0 : result;        //没找到就返回0，找到返回结果
    }
    //滑动窗口法----O(n)
    int minSubArrayLen2(int target, vector<int>& nums) {
        int result = INT32_MAX;         //存放结果
        int j = 0;                      //窗口终止指针
        int i = 0;                      //窗口起始指针
        int sum = 0;                    //窗口内元素的和
        for (j = 0; j < nums.size(); j++)       //以终止指针为索引，跳出暴力解法的怪圈
        {
            sum += nums[j];
            /*不断移动起始指针，直到找到最小的符合条件的数组，如果用if没法找到最小的
            * 例：[1 1 1 100]，target == 100
            */
            while (sum >= target)       
            {
                int length = j - i + 1;
                result = result > length ? length : result;     //更新结果
                sum -= nums[i++];              //移动起始指针，寻找最小数组（精髓之处）
            }
        }
        return result == INT32_MAX ? 0 : result;
    }
};

小结（时间紧迫，摘抄代码随想录）：

• 窗口内是什么？
• 如何移动窗口的起始位置？
• 如何移动窗口的结束位置？

窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。

窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）。

窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，也就是for循环里的索引。

时间复杂度为什么是O(n)还不太理解，后续解决

三、LeetCode 59.螺旋矩阵 II

题目链接：https://leetcode.cn/problems/spiral-matrix-ii/

• 补充语法基础知识：

  用vector创建一个二维数组：vector<vector>(n, vector(n, 0));

  解题思路

• 本题主要是要模拟填充整个矩阵的过程，首先要知道该如何循环，即一圈一圈的循环，每一次都按照循环不变量原则一层一层的填充

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

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

  由外向内一圈一圈这么画下去。

vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> result(n, vector<int>(n, 0));      //用vector初始化创建一个二维数组
        int loop = n / 2;   //顺时针转圈画矩阵的的次数（由外向内）
        int startx = 0, starty = 0; //每次开始填充的起始坐标
        int count = 1;  // 用来给矩阵中每一个空格赋值
        int offset = 1; // 需要控制每一条边遍历的长度，每次循环右边界收缩一位
        int mid = n / 2;//n为奇数时，中间元素特殊处理
        while (loop--)
        {
            int x = startx;
            int y = starty;
            //填充上行从左到右(左闭右开)
            for (; y < n - offset; y++)
            {
                result[x][y] = count++;      
            }
            //填充右行从上到下(上闭下开)
            for (; x < n - offset; x++)
            {
                result[x][y] = count++;
            }
            //填充下行从右到左(右闭左开)
            for (; y > starty; y--)
            {
                result[x][y] = count++;
            }
            //填充左行从下到上(下闭上开)
            for (; x > startx; x--)
            {
                result[x][y] = count++;
            }

            //开始下一圈填充时，起始左边加一
            startx++;
            starty++;

            //控制每一条边遍历的长度，每次循环右边界收缩一位
            offset++;
        }//end of while
        
         //n为奇数时，中间元素特殊处理
        if (n % 2)
        {
            result[mid][mid] = count;
        }
        return result;
    }