卡尔算法训练营第二天，977.有序数组的平方，209.长度最小的子数组，59.螺旋矩阵II

977.有序数组的平方

题目建议： 本题关键在于理解双指针思想

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

文章讲解：https://programmercarl.com/0977.%E6%9C%89%E5%BA%8F%E6%95%B0%E7%BB%84%E7%9A%84%E5%B9%B3%E6%96%B9.html

视频讲解： https://www.bilibili.com/video/BV1QB4y1D7ep

给你一个按 非递减顺序 排序的整数数组 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]

思路：因为数组是非递减的，并且可以为负数，那么很有可能中间的数平方后是最小的，两头的数平方后是最大的。所以可以使用双指针写法。

class Solution {
    public int[] sortedSquares(int[] nums) {
        int left = 0;
        int right = nums.length-1;
        int[] newInt = new int[nums.length];
        for (int i = nums.length - 1; i >= 0; i--) {
            int left2 = nums[left] * nums[left];
            int right2 = nums[right] * nums[right];

            if (right2 >= left2){
                right -- ;
                newInt[i] = right2;
            }else{
                left ++ ;
                newInt[i] = left2;
            }
        }
        return newInt;
    }
}

209.长度最小的子数组

题目建议： 本题关键在于理解滑动窗口，这个滑动窗口看文字讲解 还挺难理解的，建议大家先看视频讲解。 拓展题目可以先不做。

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

文章讲解：https://programmercarl.com/0209.%E9%95%BF%E5%BA%A6%E6%9C%80%E5%B0%8F%E7%9A%84%E5%AD%90%E6%95%B0%E7%BB%84.html

视频讲解：https://www.bilibili.com/video/BV1tZ4y1q7XE

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

输入：s = 7, nums = [2,3,1,2,4,3] 输出：2 解释：子数组 [4,3] 是该条件下的长度最小的子数组。

提示：

• 1 <= target <= 10^9
• 1 <= nums.length <= 10^5
• 1 <= nums[i] <= 10^5

思路:首先想到的是，从左往右，先取一个数，进行比较一轮，如果一个数没有比target大或者相等的，那么再取两个数的和，以此类推，直至取到合适的数，如果遍历完了，都没有的话，就返回0，这种思路就好比暴力解法，超时了。

暴力解法，使用两层for循环，第一层表示区间的起点，第二层表示区间的个数，这样就可以把所有区间的情况遍历出来。但是这样会超时。

滑动窗口：滑动窗口实现也是使用双指针，利用一个for循环代替两个for循环，其精髓在于for循环的j代表的是区间的末尾（如果j代表起点的话，就又好像两层for循环了），当for循环的末尾找到一个区间内的数大于等于target的时候，再缩小区间起点位置，取最优的解，（比如数组为：1，1，1，1，100，这样可能就取100就可以了，所有要缩小起点。） 当然，得记录符合要求的最小的区间值。

//leetcode submit region begin(Prohibit modification and deletion)
    class Solution {
        public int minSubArrayLen(int target, int[] nums) {

            int sum = 0;
            int left = 0;
            int min = Integer.MAX_VALUE;
            for (int j = 0; j < nums.length; j++) {
                sum += nums[j];
//                System.out.println("start:" + left +"----" + "end:" + j + "---"+"number:" + (j-left + 1) + "sum:" +sum);
                while (sum >= target){
                    min = Math.min(min,j-left+1);
                    sum -= nums[left];
                    left++;
//                    System.out.println("start:" + left +"----" + "end:" + j + "---"+"number:" + (j-left + 1) + "sum:" +sum);
                }
            }
            return min == Integer.MAX_VALUE?0:min;
        }
    }
//leetcode submit region end(Prohibit modification and deletion)

59.螺旋矩阵II

题目建议： 本题关键还是在转圈的逻辑，在二分搜索中提到的区间定义，在这里又用上了。

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

文章讲解：https://programmercarl.com/0059.%E8%9E%BA%E6%97%8B%E7%9F%A9%E9%98%B5II.html

视频讲解：https://www.bilibili.com/video/BV1SL4y1N7mV/

给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]

思路：使用暴力的解法，生成一个包含 1 到 n2 所有元素,那么二维数组必然是n*n 的二维数组，那么我就想办法按照螺旋的方式去遍历这个数组就可以了 ，分别写一个上下左右移动的方法，然后加上上下左右的边界即可。

    public int[][] generateMatrix(int n) {
		int[][] returnInt = new int[n][n];
		int i = 1;
		int left = 0;
		int right = 0;
		int leftLimit = 0;
		int rightLimit = 0;
		int upLimit =1;
		int downLimit = 0;

		while ( i <= n * n ){

			//right
			while (right < n-rightLimit){
				returnInt[left][right] = i;
				printInt(returnInt);
				i++;
				right++;
			}
			if (i>n*n){
				break;
			}
			right--;
			left++;
			rightLimit++;
			//down
			System.out.println("left:" + left + "n-downLimit:" + (n-downLimit));
			while (left < n-downLimit){
				returnInt[left][right] = i;
				printInt(returnInt);
				i++;
				left++;
			}
			if (i>n*n){
				break;
			}
			left--;
			right--;
			downLimit++;

			//left
			while (right >= leftLimit){
				returnInt[left][right] = i;
				printInt(returnInt);
				i++;
				right--;
			}
			if (i>n*n){
				break;
			}
			right++;
			left--;
			leftLimit++;
			//up
			while (left >= upLimit){
				returnInt[left][right] = i;
				printInt(returnInt);
				i++;
				left--;
			}
			if (i>n*n){
				break;
			}
			left++;
			right++;
			upLimit++;
		}
		return  returnInt;
	}

思路2：由n可以知道需要遍历多少圈，然后由遍历第几圈可以得出来遍历时，上下左右得边界，遍历的时候，最后一个点不处理，让他作为下一次遍历的起点。这样子 代码就能简洁很多

   public int[][] generateMatrix(int n) {
		int[][] returnInt = new int[n][n];
		int loop = 0;
		int start = 0;
		int count = 1;
		int i = 0;
		int j = 0;
		while (loop ++ < n/2){
			//right
			for (j = start;j < n-loop;j++){
				returnInt[start][j] = count++;
			}

			//down
			for (i = start; i < n - loop;i++){
				returnInt[i][j] = count++;
			}
			//left
			for (;j >= loop;j--){

				returnInt[i][j] = count++;
			}

			for (;i >= loop;i--){
				returnInt[i][j] = count++;
			}

			start ++;
		}

		if (n % 2 ==1 ){
			returnInt[start][start] = count;
		}
		return  returnInt;
	}