剑指 Offer II 数组

int是java提供的8种原始数据类型之一，Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。
Integer用equals

007. 数组中和为 0 的三个数

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> ans =new ArrayList();
        Arrays.sort(nums);
        int n=nums.length;

        for(int i=0;i<n;i++)
        {
            if(i>0&&nums[i]==nums[i-1])continue;//因为排好序 以相同的数为起点 得到的三元组必定重复
            for(int j=i+1,k=n-1;j<k;j++)
            {
                if(j>i+1&&nums[j]==nums[j-1])continue;
                while(nums[i]+nums[j]+nums[k]>0&&k>=j+2)k--;
                if(nums[i]+nums[j]+nums[k]==0)ans.add(Arrays.asList(nums[i],nums[j],nums[k]));
            }
        }
        return ans;
    }
}

008. 和大于等于 target 的最短子数组

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int ans=0x3f3f3f3f;//滑动窗口
        Queue <Integer> queue=new LinkedList<Integer>();
        int sum=0;
        for(int i=0;i<nums.length;i++)
        {
            queue.offer(nums[i]);
            sum+=nums[i];
            if(sum<target)continue;
            while(queue.size()>0&&sum-queue.peek()>=target)
            {
                sum-=queue.peek();
                queue.poll();
            }
            ans=Math.min(ans,queue.size());

        }
        return ans==0x3f3f3f3f?0:ans;

    }
}

009. 乘积小于 K 的子数组

class Solution {
    public int numSubarrayProductLessThanK(int[] nums, int k) {
        //固定i找最左边的j使得j乘到i<k  那么 j+1乘到i也小于k
         int ans=0,p=1,j=0;
        for(int i=0;i<nums.length;i++)
        {
            p*=nums[i];
           while(j<=i&&p>=k)p/=nums[j++];//如果一个数比target大 所以要小于等于
           ans+=i-j+1;    
        }
        return ans;
    }
}

010. 和为 k 的子数组

class Solution {
    public int subarraySum(int[] nums, int k) {
        int n=nums.length,ans=0;
      int [] sum =new  int [n+1];
      for(int i=1;i<=n;i++)sum[i]=sum[i-1]+nums[i-1];
      Map<Integer,Integer> map = new HashMap<>();
      /*
      右端点i j=0~i-1
      s[i]-s[j]==k j+1~i这段等于k
      s[j]==s[i]-k;

      */
      sum[0]=0;
      map.put(0,1);//i==1时 还没遍历 第一个s[j]是s[0]
      for(int i=1;i<=n;i++)
      {
          int x=sum[i]-k;
          if(map.containsKey(x))ans+=map.get(x);   //如果存在s[j]==s[i]-k      
          map.put(sum[i],map.getOrDefault(sum[i],0)+1);//把新的s[j]放进去

      }
     
      return ans;

    }
}

011. 0 和 1 个数相同的子数组

class Solution {
    public int findMaxLength(int[] nums) {
        int res=0;
        int n=nums.length;
        int []one= new int[n+1];
        int []zr= new int[n+1];
        /*
        固定右端点i j从0到i-1
        one[i]-one[j]==zr[i]-zr[j]
    one[j]-zr[j]  ==  one[i]-zr[i]
        */
        for(int i=1;i<=n;i++)
        {
          one[i]=one[i-1];
          zr[i]=zr[i-1];
          if(nums[i-1]==1)one[i]++;
          else zr[i]++;
        }
       //map存one[j]-zr[j]的j (下标）
        Map<Integer,Integer> map = new HashMap<>();
        map.put(0,0);//一开始one[0]-zero[0]=0 下标为0
         for(int i=1;i<=n;i++)
         {
             int x=one[i]-zr[i];
             if(map.containsKey(x))res=Math.max(res,i-map.get(x));
             else map.put(x,i);
         }     
        return res;
    }
}

012. 左右两边子数组的和相等

class Solution {
    public int pivotIndex(int[] nums) {
        int res=-1;
        int n=nums.length;
        int []sum= new int[n+1];
        for(int i=0;i<n;i++)
        {
            sum[i+1]=sum[i]+nums[i];
        }
         for(int i=1;i<=n;i++)
         {
             if(sum[i-1]==sum[n]-sum[i+1 -1])return i-1;
         }
        return res;

    }
}

013. 二维子矩阵的和

class NumMatrix {
    int [][]s;

    public NumMatrix(int[][] matrix) {
        int n=matrix.length,m=matrix[0].length;
        s= new int [n+1][m+1];
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                s[i][j]=s[i][j-1]+s[i-1][j]-s[i-1][j-1]+matrix[i-1][j-1];
            }
        }
    }
    public int sumRegion(int row1, int col1, int row2, int col2) {
        row1++;
        col1++;
        row2++;
        col2++;
        return s[row2][col2]-s[row2][col1-1]-s[row1-1][col2]+s[row1-1][col1-1];
    }
}