LeetCode-Count of Range Sum

Given an integer array nums, return the number of range sums that lie in [lower, upper] inclusive.
Range sum S(i, j) is defined as the sum of the elements in nums between indices i and j (i ≤ j), inclusive.

Note:
A naive algorithm of O(n²) is trivial. You MUST do better than that.

Example:
Given nums = [-2, 5, -1], lower = -2, upper = 2,
Return 3.
The three ranges are : [0, 0], [2, 2], [0, 2] and their respective sums are: -2, -1, 2.

Credits:
Special thanks to @dietpepsi for adding this problem and creating all test cases.

Analysis:

See this post: http://huntzhan.org/leetcode-count-of-range-sum/

Solution:

Divide and Conquer O(nlogn)

public class Solution {
   public int countRangeSum(int[] nums, int lower, int upper) {
        if (nums.length==0) return 0;
        
        long[] sums = new long[nums.length];
        long sum = 0;
        for (int i=0;i<nums.length;i++){
            sum += nums[i];
            sums[i] = sum;
        }
        
        int res = countRangeSumRecur(sums,0,sums.length-1,lower,upper);
        
        return res;
    }
    
    public int countRangeSumRecur(long[] sums, int start, int end, int lower, int upper){
        if (start==end){
            return (sums[start]>=lower && sums[start]<=upper) ? 1 : 0;
        }
        
        int len = end-start+1;
        long[] cache = new long[len];
        int mid = (start+end)/2;
        int leftCount = countRangeSumRecur(sums,start,mid,lower,upper);
        int rightCount = countRangeSumRecur(sums,mid+1,end,lower,upper);
        int res = leftCount + rightCount;
        
        // Count those cross left part and right part.
        int l1 = start, r1 = mid+1, r2 = mid+1, i1=mid+1;
        int ind = 0;
        while (l1<mid+1){
            // Get r1 and r2 into correct places.
            while (r1<=end && sums[r1]-sums[l1]<lower) r1++;
            while (r2<=end && sums[r2]-sums[l1]<=upper) r2++;
            res += r2-r1;
            
            // Perform sorting work.
            while (i1<=end && sums[i1]<=sums[l1]){
                cache[ind++] = sums[i1++];                
            }
            cache[ind++] = sums[l1];
            l1++;
        }
        while (i1<=end){
            cache[ind++] = sums[i1++];
        }
        
        for (int i=0;i<len;i++){
            sums[start+i] = cache[i];
        }
        
        return res;
    }
}