LeetCode刷题系列：LeetCode 523. 连续的子数组和

题目：给定一个包含非负数的数组和一个目标整数 k，编写一个函数来判断该数组是否含有连续的子数组，其大小至少为 2，总和为 k 的倍数，即总和为 n*k，其中 n 也是一个整数。

输入: [23,2,4,6,7], k = 6
输出: True
解释: [2,4] 是一个大小为 2 的子数组，并且和为 6。

输入: [23,2,6,4,7], k = 6
输出: True
解释: [23,2,6,4,7]是大小为 5 的子数组，并且和为 42。

说明:

1. 数组的长度不会超过10,000。
2. 你可以认为所有数字总和在 32 位有符号整数范围内。

 思路：以sum[i] 表示从下标0 到 下标 i 子数组的和，则下标  i 到 j的子数组，记为 [i,j]的和为 sum[j] - sum[i-1],
   子数组 [i,j] 如果是 k 的倍数，则有 (sum[j] - sum[i-1])%k 等于 0 ,即 sum[j]%k == sum[i-1]%k。
   我们可以用一个 map结构存放 (sum[i]%k，index) 的值，index为下标，再遍历 map 结构，
   1、当key==0时，     *   
       只需要数组中有两个连续的 0 即可
   2、当key！=0时
     1）如果对应的链表只有一个元素，即只有一个下标时，看是否该下标 i 大于1（因为要求数组大小最少为2），是的话，则证明sum[i]%k == 0，子数组[0,i]之和为k的倍数
     2）如果对应的链表有两个及以上个元素，则说明一定满足有个子数组长度大于2 ，且和为k 的倍数的条件
      注意: 子数组有两个连续的0时，也算做满足条件，因为 (0 + 0) /k = 0

public boolean checkSubarraySum(int[] nums, int k) {

    boolean flag = false;
    if(nums.length<2){
        return false;
    }
    Map<Integer,List<Integer>>  map = new HashMap<>(); //key = sum[i]%k ,value = [index1,index2,...]

    if(k!=0) {
        int[]  sum = new int[nums.length];  //存放数组从下标0开始，到当前下标i的和sum[i]
        for(int i=0;i<nums.length;i++){
            if(i==0){
                sum[i] = nums[i];
            }else {
                if(nums[i] ==0 && nums[i-1] == 0){ // 子数组有两个连续的0时，也算做满足条件，因为 (0 + 0) /k = 0
                    flag = true;
                    break;
                }
                sum[i] = sum[i-1] + nums[i];
            }
        }
        //填充 map 结构，key = sum[i]%k ,value = [index1,index2,...]
        for(int i=0;i<sum.length;i++){
            int key = sum[i]%k;
            if(!map.containsKey(key)){
                List<Integer> list = new ArrayList<>();
                list.add(i);
                map.put(key,list);
            }else {
                map.get(key).add(i);
            }
        }

            for(Map.Entry<Integer,List<Integer>> entry:map.entrySet()){
                if(entry.getKey()==0){
                    if(map.get(0).size()>=2){
                        flag = true;
                        break;
                    }else if(map.get(0).get(0)>=1){
                        flag = true;
                        break;
                    }
                }
                List<Integer>  list = entry.getValue();
                for (int i= list.size()-1;i>0;i--){
                    int index = list.get(i);
                    if(nums[index]!=0&&index-list.get(0)>1){ //排除类似于 [2,0] k = 2 这种情况
                        flag = true;
                        break;
                }
                if(flag){
                    break;
                }
            }
            if(flag){
                break;
            }
        }
    }else {
        for (int i = 1; i < nums.length; i++) {
            if(nums[i-1] == 0 && nums[i] ==0){   //当 k等于 0的时候，只需要数组中有两个连续的 0 即可
                flag = true;
                break;
            }
        }
    }

    return flag;
}