算法之最左前缀

1）最左前缀基于一些数学原理，如s1-s2之差是k的倍数，则s1%k和s2%k一定相同，因为余数相同，则在相减的时候就减去了；另外当num[1]和num[2]均为正数时，(num[1]+num[2])%k等于(num[1]%k+num[2])%k；力扣523题，求连续数组和为k的倍数，就基于以上规律；

 public static boolean checkSubarraySum(int[] nums, int k) {
        //方法一，前缀和 一次遍历，但并不会求出前缀和数组，而是变计算前缀和，边判断
        int m = nums.length;
        if (m < 2) {
            return false;
        }
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        //map先加入0，当出现数组前几位之和对k取余为0，则表示ok
        //若map中不加入0，则会遗漏这种情况
        map.put(0, -1);
        int remainder = 0;
        for (int i = 0; i < m; i++) {
        //边计算前缀和对k的余数，边判断
            remainder = (remainder + nums[i]) % k;
            if (map.containsKey(remainder)) {
                int prevIndex = map.get(remainder);
                if (i - prevIndex >= 2) {
                    return true;
                }
            } else {
                map.put(remainder, i);
            }
        }
        return false;
    }

力扣974题，求和可被k整除的子数组，与上边题目几乎一样，但974题给出的数组每个元素可为负数，而523题规定数组每个数为正数，为负数时这时候上边的(num[1]+num[2])%k等于(num[1]%k+num[2])%k就不成立了；所以针对974题，此时就每次求和，每次求一遍余数，代码如下；

 public static int subarraysDivByK(int[] nums, int k) {
        Map<Integer,Integer> map = new HashMap();
        map.put(0,1);
        int sum=0,count=0;
        //int yushu=0;
        for (int num : nums) {
            sum+=num;
            int d = (k + sum % k) % k;
            //如果按照下边注释的步骤，就会对[4,5,0,-2,-3,1], k = 5的输入
            // 余数与-2，-3相加就会出问题，余数本来就“小”，再加上负数就会更小了，但如果
            //正常求和计算，就不会有错误，如[4,5,0,-2,-3]之和对5求余数为4，但按照注释的
            //方法就会出现余数2加-3，等于-1，-1对5取余等于-1，不为4，出现遗漏；
//            yushu=(yushu+num)%k;
//            int d=yushu;
            if(map.containsKey(d)){
                count+=map.get(d);
            }
            map.put(d,map.getOrDefault(d,0)+1);
        }
        return count;
    }

另外求余数这个地方不能写成

int d=sum % k;

因为负数的情况求余数需要转为正数，所以要写成

int d=(k + sum % k)%k

括号中加上k，保证是正数；否则按照int d=sum % k算法，对于输入为以下，就会只有一个数组，实际上有两个数组；因为-1%2结果为-1，但需要加上2转为1；

[-1,2,9]
2

力扣560题，和为k的子数组，原理类似，注意也要开始在map中放入0；

public static int subarraySum(int[] nums, int k) {
 if (nums.length == 0) {
            return 0;
        }
        HashMap<Integer,Integer> map = new HashMap<>();
        //细节，这里需要预存前缀和为 0 的情况，会漏掉前几位就满足的情况
        //例如输入[1,1,0]，k = 2 如果没有这行代码，则会返回0,漏掉了1+1=2，和1+1+0=2的情况
        //输入：[3,1,1,0] k = 2时则不会漏掉
        //因为presum[3] - presum[0]表示前面 3 位的和，所以需要map.put(0,1),垫下底
        map.put(0, 1);
        int count = 0;
        int presum = 0;
        for (int x : nums) {
            presum += x;
            //当前前缀和已知，判断是否含有 presum - k的前缀和，那么我们就知道某一区间的和为 k 了。
            if (map.containsKey(presum - k)) {
            //如中间存在元素0，但和不受影响，但同样也满足
                count += map.get(presum - k);
            }
            //更新
            map.put(presum,map.getOrDefault(presum,0) + 1);
        }
        return count;
    }

2）力扣724题，寻找数组中心下标，则可以先求出前缀和数组，再遍历前缀和数组，写出恒等式；代码如下

 public static int xunZhaoShuZuZxxb(int[] nums){
        int[] preSum = new int[nums.length + 1];
        for (int i = 0; i < nums.length; i++) {
            preSum[i+1]=preSum[i]+nums[i];
        }
        for (int i = 1; i < preSum.length; i++) {
            if(preSum[i-1] == preSum[preSum.length-1]-preSum[i]){
                return i;
            }
        }
        return -1;
    }