leetcode刷题 day2 长度最小子数组

209.长度最小子数组 

思路：这道题目要求找到连续的元素的和大于等于target，并且是最小的连续数组。

用暴力求解的话，就需要用两层for循环，第一层找起点位置，第二层找对应的终点位置，2个索引共同运行，并且迭代最小值，一定会找出最小的子数组。 

现在把复杂度从O（N^2）降低到O（n），需要用到双指针的思想。 难点就是要想清楚一个for循环定义起点还是终点。这里必须定义终点，起点用缩减sum空间的方式，从left=0开始往右找。 

找到满足大于等于target同时，且起点和终点距离最短的那个，返回结果。

代码如下： 

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left=0;
        int sum=0;
        int resultLength = Integer.MAX_VALUE;
        int subLength =0;
        for(int right=0; right<nums.length; right++){
            sum+= nums[right];
            while(target<=sum){
                subLength =right-left+1;
                resultLength =  resultLength<subLength?resultLength: subLength;//及时更新子长度
                //滑动left，往右靠拢
                sum -=nums[left++];
            }
        }
        
        return  resultLength ==Integer.MAX_VALUE? 0: resultLength;
    }
}

59.螺旋矩阵II

这个题目的主要是找到规律，最外层，顶部，右边，底边，左侧，然后第二层循环，左开右闭的进行填充  

1.这个圈数的定义为何是n/2， 是因为我们考虑最后留下来的有效边，

从一开始的n*n，类推：

• 第一圈：从 n×n 到 (n−2)×(n−2)
• 第二圈：从 (n−2)×(n−2) 到 (n−4)×(n−4)
• 依此类推，直到矩阵变得无法再形成完整的一圈。
• 当 n 是奇数时，最后会有一个中心的元素。
• 当 n 是偶数时，最后会没有中心元素，只会有一个完整的矩阵。

圈数的推导：

• 所以，我们可以列出这样的不等式： n−2×k≥0其中 k 是圈数。
• 从这个不等式可以推导出圈数 k的最大值： k≤n/2
• 这说明，最大圈数 k为 ⌊n/2⌋，也就是用整数除法得出的结果。

2. 第一圈外圈走完后，里面的圈子数据变化

在完成第一圈的填充后，为了填充内部圈子，startX 和 startY 要增加 1，这样就会开始在更小的矩阵上填充数据。每完成一圈，你的起始点 (startX, startY) 会向内移动，从而确保下一圈不会覆盖之前的数字

3. 奇数和偶数矩阵的处理

代码逻辑在处理奇数矩阵时能够正确填充，是因为它会在最后填充中心的元素（即当 n 为奇数时）。对于偶数矩阵，实际上不需要在最后单独处理一个中心元素，因为没有中心点。

4.填充的边界问题

• 填充四条边时的边界条件：在填充每一圈的四条边时，我之前用的 for 循环使用 j < n - 1 和 i < n - 1 之类的条件，直接用 n-1 而没有考虑到每次循环后 n 实际上是缩小的（即只应填充未被覆盖的部分）。这在偶数矩阵时会导致多填或少填。 实际要用到一个变化量offset，每多一圈，offset增加 1，动态地使用 n - offset 来调整每一圈的边界，这样j<n-offset ,i<n-offset 就能控制好边界问题。 

• offset 和 loop 的问题：我之前设定的 offset 和 loop 没有实际被用到。loop 表示填充圈数，但没有帮助更新矩阵的边界，因此代码在偶数矩阵中无法正确完成外层的填充。 所以每一圈结束后，得及时更新loop和offset。 

class Solution {
    public int[][] generateMatrix(int n) {
       int [][] matrix = new int [n][n];//定义一个二维数组； 
        int i, j; 
        int offset =1;
        //列的起始位置，行的起始位置
        int startX=0 ;
        int startY=0;
        //根据n的大小，求膜来判断填充的圈数
        int loop =1;
        int fillNum =1;

      while (loop<=n/2){
        //填充第一行 
        for(j=startY;j<n-offset;j++){//左闭右开 
            matrix[startX][j]=fillNum;
            fillNum++;
        }
        //填充最右侧列 
        for(i=startX; i<n-offset;i++){
            matrix[i][j] =fillNum;
            fillNum++;
        }
        //最外侧底层
        for( ;j>startY;j--){
            matrix[i][j]=fillNum;
            fillNum++;
        }
        //最外 左侧
        for( ;i>startX;i--){
            matrix[i][j]=fillNum;
            fillNum++; 
        }
        startX +=1;
        startY +=1;
        loop++ ;
        offset++;
      }
      if(n%2 ==1){
        matrix[startX][startY]= fillNum;
      }
      return matrix;
    }
}

58 区间和 

这道题如果用暴力求解法，就是对数组进行遍历，填充和求和，基于给定的区间遍历累计求和。但是这样的时间复杂度就比较大。 如果a，b多次赋值，多次查询（m次）那么对于n的数组，其复杂度就是m*n。 

用前缀和的思路， 数组的元素和累计到一个新的数组中，根据新的这个数组的索引下标，求出来 newAraay[b]-newArray[a-1],就是我们查询的sum和。  

注意这道题是ACM输入格式，所以我们不能用 public class 类这种形式， 

一般只要求用Main类保存文件， 所以写成 class Main 

而且不能有自己定义的包。

并且在main主函数中，返回值不能用return，得用打印输出。 

代码如下 ： 

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

        int totalSum=0;
        int sum =0;
        for(int i=0;i<n;i++){
            array[i]=scanner.nextInt();
            sum+= array[i];
            sumElement[i] =sum ;
        }
        while(scanner.hasNextInt()){
            int a =scanner.nextInt();
            int b= scanner.nextInt();
            if (a==0){
                totalSum = sumElement[b];
            }else{
                totalSum= sumElement[b]-sumElement[a-1];
            }
            System.out.println(totalSum);
        }
        scanner.close();
        
    }
    
}

44.开发商购买土地

这个题目的逻辑就是按照行或者列进行切割， 必须是一刀切，而且是纵向或者横向，不能有折线的方式进行分割。 这就考虑一刀分割后， 2个part之间的差的abs 是不是无限接近0 ，就能比较出2part是不是近似相等。 

按照行分割，有n-1种刀法， 需要一个新的数组来存储每一行的元素总和。 之后再设置一个新的数组， 来存储 前i行的分别累计值， ，然后调用math.min ，math.abs(part1-part2) ,比较前i行的值和剩下行的值之间的差。 同理作用到列的分割。 进行最小值的比较和替换。  

代码如下：

import java.util.Scanner;
class Main{
    public static void  main(String [] args){
        Scanner scanner = new Scanner(System.in);
        int result = Integer.MAX_VALUE;
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int[][] array = new int[n][m];
        int totalSum = 0;
        int[] subSumVertical = new int[m - 1];
        int[] subSumHorizontal = new int[n - 1];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                array[i][j] = scanner.nextInt();
                totalSum += array[i][j];
            }
        }
        //按照列进行切割
        for (int j = 0; j < m - 1; j++) {
            for (int i = 0; i < n; i++) {
                subSumVertical[j] += array[i][j];
            }
        }
        //按照行进行切割
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < m; j++) {
                subSumHorizontal[i] += array[i][j];
            }
        }
        //求出math.min 的最小值
        int cutVertical = 0;
        int cutHorizontal = 0;

        for (int i = 0; i < subSumHorizontal.length; i++) {
            cutHorizontal += subSumHorizontal[i];
            result = Math.min(result, Math.abs((totalSum -  - cutHorizontal) - cutHorizontal));

        }
        for (int i = 0; i < subSumVertical.length; i++) {
            cutVertical += subSumVertical[i];
            result = Math.min(result, Math.abs((totalSum - cutVertical) - cutVertical));
        }
        System.out.println(result);
        scanner.close();
    }
}