[LintCode] Subarray Sum II

Given an integer array, find a subarray where the sum of numbers is in a given interval. Your code should return the number of possible answers. (The element in the array should be positive)

Example

Given [1,2,3,4] and interval = [1,3], return 4. 

Brainstorming:

This problem asks for all possible answers,  which can be O(n^2) in the worst case(all subarrays' sum are inside the given interval).  Dynamic programming is not useful most of the time

when a problem asks for all possible answers.  Because the worst case has O(n^2) answers, so the BCR can not be better than O(n^2) as we need to iterate all subarrays to get the 

correct answer. 

So the optimal solution is O(n^2) runtime, which usually comes at the format of a nested for loop. 

Solution 1. O(n^3) runtime, O(1) space 

A straightforward solution is to enumerate all possible subarrays in O(n^2) time, then for each subarray, get its sum and check if this sum is in the given interval. 

The implementation of this solution is shown as follows. 

public class Solution {
    /**
     * @param A an integer array
     * @param start an integer
     * @param end an integer
     * @return the number of possible answer
     */
    public int subarraySumII(int[] A, int start, int end) {
        if(A == null || A.length == 0 || end < start){
            return 0;
        }
        int cnt = 0;
        for(int j = 0; j < A.length; j++){
            for(int i = 0; i <= j; i++){
                int sum = subSum(A, i, j);
                if(sum >= start && sum <= end){
                    cnt++;
                }
            }
        }
        return cnt;
    }
    private int subSum(int[] A, int left, int right){
        int r = 0;
        for(int i = left; i <= right; i++){
            r += A[i];
        }
        return r;
    }
}

Solution 2. O(n^2) runtime, O(n) space with prefix sum.

Solution 1's runtime is O(n^3), not the optimal O(n^2). Applying the BUD(Bottlenecks, Unnecessary work,

Duplicated work) principle, we know that we are doing duplicated work when getting a subarray's sum.  

Why? 

Each time we fix the start and end indices of a subarray,  it is only one element different from the previously checked subarray. But this solution does not use this 

condition. Instead, it calculates a subarray's sum from stratch. What can be optimized here is that we use prefix sum and calculate the sum of the first ith elements 

for i = 0, 1, ...... n;  This preprocessing step takes O(n) time and O(n) space. When calculating a subarray's sum, only a O(1) subtraction is needed , thus making 

its runtime to the optimal O(n^2).

This is similiar with the relation between straightforward recursion and dynamic programming. Sacrifice some space for a faster runtime.

public class Solution {
    public int subarraySumII(int[] A, int start, int end) {
        if(A == null || A.length == 0 || end < start){
            return 0;
        }
        int[] prefixSum = new int[A.length + 1];
        prefixSum[0] = 0;
        for(int i = 1; i <= A.length; i++){
            prefixSum[i] = prefixSum[i - 1] + A[i - 1];
        }
        int cnt = 0;
        for(int i = 0; i < A.length; i++){
            for(int j = i + 1; j <= A.length; j++){
                int diff = prefixSum[j] - prefixSum[i];   
                if(diff >= start && diff <= end){
                    cnt++;
                }
            }
        }
        return cnt;
    }
}

Solution 3. O(n^2) runtime, O(1) space 

We can further optimize the memory usage from O(n) to O(1). A single integer totalSum is used to keep the current 
sum of A[0.....j]. Another integer variable sum is used to keep the current sum of A[i.......j].

public class Solution {
    public int subarraySumII(int[] A, int start, int end) {
        if(A == null || A.length == 0 || end < start){
            return 0;
        }
        int totalSum = 0;
        for(int i = 0; i < A.length; i++){
            totalSum += A[i];
        }
        int cnt = 0;
        for(int j = A.length - 1; j >= 0; j--){
            int sum = totalSum;
            for(int i = 0; i <= j; i++){
                if(i > 0){
                    sum -= A[i - 1];
                }
                if(sum >= start && sum <= end){
                    cnt++;
                }
            }
            totalSum -= A[j];
        }
        return cnt;
    }
}

Related Problems
Subarray Sum
Subarray Sum Closest