有序数组的平方

977. 有序数组的平方

思路&重点

重点

• 非递减顺序 排序的整数数组 nums，
• 是否有负数
• 结果按非递减顺序返回
  思路
  nums = [-4,-1,0,3,10]
  平方后，数组变为 [16,1,0,9,100]
  数组其实是有序的， 只不过负数平方之后可能成为最大数了。
  那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。
  此时可以考虑双指针法了，i指向起始位置，j指向终止位置。
  定义一个新数组result，和A数组一样的大小，让k指向result数组终止位置。
  如果A[i] * A[i] < A[j] * A[j] 那么result[k–] = A[j] * A[j]; 。
  如果A[i] * A[i] >= A[j] * A[j] 那么result[k–] = A[i] * A[i]; 。

双指针法

class Solution {
    public int[] sortedSquares(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        int index = nums.length - 1;
        int leftRes, rightRes;
        int res[] = new int[nums.length];
        while(left <= right){
            leftRes = nums[left] * nums[left];
            rightRes = nums[right] * nums[right];
            if (leftRes <= rightRes){
                res[index--] = rightRes;
                right--;
            } else{
                res[index--] = leftRes;
                left++;
            }
        }
        return res;
    }
}

class Solution {
    public int[] sortedSquares(int[] nums) {
        int l = 0;
        int r = nums.length - 1;
        int[] res = new int[nums.length];
        int j = nums.length - 1;
        while(l <= r){
            if(nums[l] * nums[l] > nums[r] * nums[r]){
                res[j--] = nums[l] * nums[l++];
            }else{
                res[j--] = nums[r] * nums[r--];
            }
        }
        return res;
    }
}

长度最小的子数组

209. 长度最小的子数组 - 力扣（LeetCode）

给定一个含有 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

思路&重点

重点

• 连续子数组

思路
滑动窗口，主要确定如下三点：

• 窗口内是什么？
• 如何移动窗口的起始位置？
• 如何移动窗口的结束位置？
• 窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。

窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）。
窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，窗口的起始位置设置为数组的起始位置就可以了。

解法

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int sum = 0;
        int len = Integer.MAX_VALUE;
        for(int j = 0, i = 0; j < nums.length; j++){
            sum += nums[j];
            while(sum >= target){
                len = Math.min(len, j - i + 1);
                sum -= nums[i++];
            }
        }
        return len == Integer.MAX_VALUE ? 0: len;
    }
}

螺旋矩阵II

思路

• 提到如果要写出正确的二分法一定要坚持循环不变量原则
• 确定是左开右闭，左闭右开，左开右开

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

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

解法

class Solution {
    public int[][] generateMatrix(int n) {
        int [][] res = new int[n][n];
        int count = 1; //   填充数字
        int loop = 0; // 控制循环次数
        int loopMax = n / 2; //  每个圈循环几次，例如n为奇数3，那么loop = 1 只是循环一圈，矩阵中间的值需要单独处理
        int startx = 0, starty = 0;
        while(loop <= loopMax){
            // 上行从左到右(左闭右开)
            for(int i = startx; i < n - loop - 1; i++){
                res[starty][i] = count++;
            }
            // 右行从上到下(左闭右开)
            for(int i = starty; i < n - loop - 1; i++){
                res[i][n - startx - 1] = count++;
            }
            // 下行从右到左(左闭右开)
            for(int i = n - startx - 1; i > loop; i--){
                res[n - starty - 1][i] = count++;
            }
            // 左行从下到上(左闭右开)
            for(int i = n - starty - 1; i > loop; i--){
                res[i][startx] = count++;
            }

            startx++;
            starty++;
            loop++;
        }
        if (n % 2 ==1){
            res[loopMax][loopMax] = count;
        }
        return res;
    }
}