代码随想录算法训练营42期day02

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

逻辑有点绕但还是写出来了，用的暴力的解法：

class Solution {
    public int[] sortedSquares(int[] nums) {
        int len = nums.length;
        int z=0;
        for(int i=0;i<len;i++){
            nums[i] = nums[i] * nums[i];
        }
        for(int i=0;i<len-1;i++){
            int x=i;
            for(int j = i ;j<len;j++){
            if(nums[j]<=nums[x])
                x = j;
            }
            z = nums[i];
            nums[i] =nums[x];
            nums[x] =z;
        }
         return nums;   
    }
}

后面学会了用双指针的解法：

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

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

自己写的一遍过,虽然很暴力,但是我这里忽略了题目要求的子数组，所以换个测试用例就过不了了，这里要求的子数组就是要连续的，所以我这个解法不对：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int len = nums.length;
        int z=0;
        for(int i=0;i<len-1;i++){
            int x=i;
            for(int j = i ;j<len;j++){
            if(nums[j]<=nums[x])
                x = j;
            }
            z = nums[i];
            nums[i] =nums[x];
            nums[x] =z;
        }
        int sum = 0,k=0;
        for(int i = len-1;i>=0;i--){
            sum = sum+nums[i];
            k++;
            if(sum>=target) break;

        }
        if(k == len ){
            return 0;
        }else return k;

    }
}

滑动窗口的方法，第一次做，确实厉害,主要精华一个是要while循环不停的去缩小，然后就是sum -= nums[left++]；做一个移动；

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int len = nums.length;
        int left= 0 ;
        int sum = 0 ;
        int  result = Integer.MAX_VALUE;
        for(int right =0; right<len;right++){
            sum += nums[right];
            while(sum >= target){
            result = Math.min(result,right-left +1);
            sum -= nums[left++]; 

            }
        } 
        return  result == Integer.MAX_VALUE ? 0 : result;

    }
}

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/

这题感觉思路比较固定，所以就按照参考答案来了：

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] nums = new int[n][n];
        int startX = 0, startY = 0;  // 每一圈的起始点
        int offset = 1;
        int count = 1;  // 矩阵中需要填写的数字
        int loop = 1; // 记录当前的圈数
        int i, j; // j 代表列, i 代表行;

        while (loop <= n / 2) {

            // 顶部
            // 左闭右开，所以判断循环结束时， j 不能等于 n - offset
            for (j = startY; j < n - offset; j++) {
                nums[startX][j] = count++;
            }

            // 右列
            // 左闭右开，所以判断循环结束时， i 不能等于 n - offset
            for (i = startX; i < n - offset; i++) {
                nums[i][j] = count++;
            }

            // 底部
            // 左闭右开，所以判断循环结束时， j != startY
            for (; j > startY; j--) {
                nums[i][j] = count++;
            }

            // 左列
            // 左闭右开，所以判断循环结束时， i != startX
            for (; i > startX; i--) {
                nums[i][j] = count++;
            }
            startX++;
            startY++;
            offset++;
            loop++;
        }
        if (n % 2 == 1) { // n 为奇数时，单独处理矩阵中心的值
            nums[startX][startY] = count;
        }
        return nums;
    }
}