【每日一题】符合区间范围的子数组

题目

给定一个数组，以及[lower，upper]的限定范围，计算有多少个子数组的累加和在当前的限定范围上

解析

这里使用的思路还是归并排序的思路，在归并排序的过程中，计算符合范围的数组，那么可以先计算前缀和，然后通过逆向的方式，通过以N结尾的前缀和减去需要将计算范围，然后看当前的数是否符合当前的新的范围即可（以N结尾的子数组的累加和Y可以转换为：是否有N-X的数组的累加和在[Y-upper, Y-lower]）

代码实现

 public int countOfRangeSum(int[] arr, int lower, int upper) {
     if(arr == null || arr.length == 0) {
         return 0;
     }
     // 计算前缀和
     int[] sum = new int[arr.length];
     sum[0] = arr[0];
     for (int i = 1; i < arr.length; i++) {
         sum[i] = sum[i - 1] + arr[i];
     }

     return process(sum, 0, sum.length - 1, lower, upper);
 }


// 这里只传进来sum前缀和数组
// 计算arr[L...R]范围上，有多少子数组累加和在[lower、upper]上
private int process(int[] sum, int L, int R, int lower, int upper) {
    if(L == R) {
        return sum[L] >= lower && sum[R] <= upper ? 1 : 0;
    }
    int mid = L + ((R - L) >>  1);
    return process(sum, L, mid, lower, upper)
        + process(sum, mid + 1, R, lower, upper)
        + merge(sum, L, mid, R, lower, upper);
}

/**
  * 以N结尾的子数组的累加和Y可以转换为：是否有N-X的数组的累加和在[Y-upper, Y-lower]
  *
  */
private int merge(int[] sum, int L, int mid, int R, int lower, int upper) {
    // [L...mid] [mid+1...R]
    int windowL = 1;
    int windowR = 1;
    int ans = 0;
    for (int i = mid + 1; i < R; i++) {
        // 转换限定范围
        int min = sum[i] - upper;
        int max = sum[i] - lower;
        while (windowL <= mid && sum[windowL] < min) {
            windowL++;
        }
        while (windowR <= mid && sum[windowR] <= max) {
            windowR++;
        }
        // 统计每个数作为结尾的符合条件的数量
        ans += windowR - windowL + 1;
    }

    int[] help = new int[R - L + 1];
    int p1 = L;
    int p2 = mid + 1;
    int index = 0;
    while (p1 <= mid && p2 <= R) {
        help[index++] = sum[p1] < sum[p2] ? sum[p1++] : sum[p2++];
    }
    while (p1 <= mid) {
        help[index++] = sum[p1++];
    }
    while (p2 <= R) {
        help[index++] = sum[p2++];
    }
    for (int i = 0; i < help.length; i++) {
        sum[L + i] = help[i];
    }

    return ans;
}