代码随想录day2：长度最小的子数组，螺旋矩阵II，区间和，开发商购买土地

1. 长度最小的子数组

• 暴力法
  暴力法就是用两层for循环来分别遍历，其中外层循环是用来遍历起始位置，内层循环则是用来遍历结束位置，时间复杂度是O(n^2)。
• 滑动窗口法
  滑动窗口法也利用了双指针的思想。只用一个for循环，循环的索引 一定是表示滑动窗口的终止位置。
  窗口就是 满足其和>=s的长度最小的连续子数组。窗口的起始位置如何移动：如果当前窗口的值大于等于s了，窗口就要向前移动。

    public int minSubArrayLen(int target, int[] nums) {
        //滑动窗口
        int i =0;
        int sum =0;
        int result = Integer.MAX_VALUE;
        for (int j=0;j<nums.length;j++){
            sum +=nums[j];
            while(sum>=target){
                result = Math.min(result,j-i+1);
                sum -= nums[i++];
            }
        }
        return result ==Integer.MAX_VALUE ? 0 : result;
    }
}

2. 螺旋矩阵II
左闭右开规则

    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;
    }
}

3. 区间和
引入前缀和，前缀和的思想是重复利用计算过的子数组之和，并相减即作为下标之间的累加和。

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);

        int n =scanner.nextInt();
        int [] vec =new int[n];
        int [] p = new int[n];

        int presum = 0;
        for (int i=0;i<n;i++){
            vec[i] = scanner.nextInt();
            presum +=vec[i];
            p[i]=presum;
        }

        while(scanner.hasNextInt()){
            int a = scanner.nextInt();
            int b = scanner.nextInt();

            int sum;
            if (a==0){
                sum = p[b];
            }else{
                sum = p[b]-p[a-1];
            }
            System.out.println(sum);
        }
        scanner.close();
    }

}

4. 开发商购买土地
同样利用前缀和思路 将行方向和列方向的和求出来。

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int sum = 0;
        int[][] vec = new int [n][m];
        for (int i = 0;i < n; i++){
            for (int j = 0;j < m; j++){
                vec[i][j] = scanner.nextInt();
                sum += vec[i][j];
            }
        }

        int result = Integer.MAX_VALUE;
        int count = 0; //统计遍历过的行

        //行切分
        for (int i = 0; i < n; i++){
            for (int j = 0; j < m; j++){
                count += vec[i][j];
                //遍历到行末尾时候开始统计
                if (j == m - 1){
                    result = Math.min(result,Math.abs(sum - 2*count));
                }
            }
        }
        count = 0;
        
        //列切分
        for (int j = 0; j < m; j++){
            for (int i = 0; i < n; i++){
                count += vec[i][j];
                //遍历到列末尾时候开始统计
                if (i == n - 1){
                    result = Math.min(result,Math.abs(sum - 2*count));
                }
            }

        }
        System.out.println(result);
        scanner.close();


    }
}