前缀和大集合(子数组=target问题，子矩阵=target问题)

example 1：

含有相同数量的0和1，就意味着这样的子数组长度是这个区间和的二倍，那么可以推导出这样一个公式：
sum[cur]-sum[pre]=2(cur-pre) =>sum[pre]-2pre=sum[cur]-2cur; sum[i]表示前i个元素和
同时cur-pre>=2;所以判断的时候从i=2开始判断, 用哈希表存放所有元素的sum[pre]-2pre和对应子数组长度，第一个应该是（0，0），后续只要判断是否存在2*sum[i]-i,如果存在就结果=当前长度-map.get(k)

class Solution {
    public int findMaxLength(int[] nums) {
    int res=0,len=nums.length;
    HashMap<Integer,Integer> map=new HashMap<>();
    int []sum=new int[len+1];
    for(int i=1;i<=len;i++){
      sum[i]=sum[i-1]+nums[i-1];
    }
    for(int i=1;i<=len;i++){
       int  k=2*sum[i]-i;
        if(map.containsKey(k)){
              res=Math.max(res,i-map.get(k));
        }
       if (!map.containsKey(2*sum[i - 1]-i+1)) map.put(2*sum[i-1]-i+1,i-1);
        
    }
    return res;
    }
}

example 2：连续子数组

同样用公式推导 推得：(sum[cur]-sum[pre])%k=0那么有sum[cur]%k=sum[pre]%k,cur-pre>=2;sum[i]表示前i+1个元素和

class Solution {
    public boolean checkSubarraySum(int[] nums, int k) {
        if(nums.length==1)return false;
        int []qsum=new int[nums.length];
        qsum[0]=nums[0];
          for(int i=1;i<nums.length;i++){
              qsum[i]=qsum[i-1]+nums[i];
          }
       Set<Integer> set=new HashSet<>();
       set.add(0);
       for(int i=1;i<nums.length;++i){
        if(set.contains(qsum[i]%k))return true;
           set.add(qsum[i-1]%k);
         
       }
    
    return false;
    }
}

example 3：

class Solution {
    public boolean[] canEat(int[] candiesCount, int[][] queries) {
    long []countc=new long[candiesCount.length];
    countc[0]=candiesCount[0];
    for(int i=1;i<candiesCount.length;i++){
      countc[i]=candiesCount[i]+countc[i-1];
    }
    boolean []res=new boolean[queries.length];
    
    for(int i=0;i<queries.length;i++){
        int limit=queries[i][2],day=queries[i][1]+1,goal=queries[i][0]; 
            long x1 = day;
            long y1 = (long) day * limit;
            long x2 = goal == 0 ? 0 : countc[goal - 1] ;
            long y2 = countc[goal];
            res[i] = x1 <= y2 && y1 >x2;
         }
        return res;
    }
   
    }

example 4：

class Solution {
    public int numSubmatrixSumTarget(int[][] matrix, int target) {
     int  ans=0;
     for(int i=0;i<matrix.length;i++){
         int []sum=new int[matrix[0].length];
         for(int j=i;j<matrix.length;j++){
             for(int k=0;k<matrix[0].length;k++){
                 sum[k]+=matrix[j][k];
             }
             ans+=check(sum,target);
         }
     }
     return ans;
    }
    public int check(int []sum,int target){
        HashMap<Integer,Integer> map=new HashMap<>();
        int res=0,presum=0;
        map.put(0,1);
        for(int x:sum){
            presum+=x;
            if(map.containsKey(presum-target))res+=map.get(presum-target);
            map.put(presum,map.getOrDefault(presum,0)+1);
        }
        return res;
    }
}

class Solution {
    public int numSubarraysWithSum(int[] nums, int goal) {
     int []prenum=new int[nums.length+1];
     for(int i=1;i<=nums.length;i++){
         prenum[i]=prenum[i-1]+nums[i-1];
     }
     Map<Integer,Integer> map=new HashMap<>();
     map.put(0,1);
     int ans=0;
     for(int i=1;i<=nums.length;i++){
           ans+=map.getOrDefault(prenum[i]-goal,0);
           map.put(prenum[i],map.getOrDefault(prenum[i],0)+1);
     }
     return ans;
    }
}