leetcode 209. Minimum Size Subarray Sum

using sliding window

class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        int l = 0, N = nums.length;
        int ret = N + 1, sum = 0;
        for (int r = 0; r < N; ++r) {
            sum += nums[r];
            for (;l <= r && sum >= s;++l) {
                ret = Math.min(ret, r - l + 1);
                sum -= nums[l];
            }
        }
        return ret == N + 1 ? 0: ret;
    }
}

And try to Using prefix sum method, the rightmost index with value <= current_sum - s must be found.

Since the prefix sum array is monotonically increasing, we can use binary search to find the target index.

But the corner case really takes a while to deal with.

class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        int N = nums.length;
        if (N == 0) return 0;
        for (int i = 1; i < N; ++i) nums[i] += nums[i - 1];
        int ret = nums[0] >= s ? 1: N + 1;
        for (int i = 1; i < N; ++i) {
            if (nums[i] < s) continue;
            int target = nums[i] - s;
            if (nums[0] > target) {
                ret = Math.min(ret, i + 1);
                continue;
            }
            int l = 0, r = i - 1;
            while (l < r) {
                int mid = l + (r - l + 1) / 2;
                if (nums[mid] <= target) {
                    l = mid;
                }
                else {
                    r = mid - 1;
                }
            }
            ret = Math.min(ret, i - l);
        }
        return ret == N + 1? 0: ret;
    }
}

Another option is using Arrays.binary search. It makes things a little simpler. But also have to deal with the annoying "what if nums[0] > target" problem.

class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        int N = nums.length;
        if (N == 0) return 0;
        for (int i = 1; i < N; ++i) nums[i] += nums[i - 1];
        int ret = nums[0] >= s ? 1: N + 1;
        for (int i = 1; i < N; ++i) {
            if (nums[i] < s) continue;
            int target = nums[i] - s;
            int idx = Arrays.binarySearch(nums, 0, i, target);
            idx = idx < -1? (-idx - 2): idx;//deal with the annoying problem.
            ret = Math.min(ret, i - idx);
        }
        return ret == N + 1? 0: ret;
    }
}