LeetCode - 209. 长度最小的子数组

描述

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

输入：s = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
 

进阶：

如果你已经完成了 O(n) 时间复杂度的解法, 请尝试 O(n log n) 时间复杂度的解法。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-size-subarray-sum/
 

求解

    class Solution {
    private:
        int getSum(const vector<int> &nums, int i, int j) {
            return std::accumulate(nums.begin() + i, nums.begin() + j + 1, 0);
        }

    public:
        // 方法一，暴力解法,超时，时间复杂度O(N*N*N)
        int minSubArrayLen_1e(int s, vector<int> &nums) {
            const int n = nums.size();
            int res = n + 1;
            for (int i = 0; i < n; ++i) {
                for (int j = i; j < n; ++j) {
                    if (getSum(nums, i, j) >= s) {
                        res = std::min(res, j - i + 1);
                        break; // 以i开始的连续子串求和已经大于0，后面的循环无效，跳出当前循环
                    }
                }
            }
            return res == n + 1 ? 0 : res;
        }

        // 方法二，暴力解法,优化求和的计算，优化以i开始的子串满足条件后跳出循环，低效率通过，时间复杂度O(N*N)
        int minSubArrayLen_2e(int s, vector<int> &nums) {
            const int n = nums.size();
            int res = n + 1;
            for (int i = 0; i < n; ++i) {
                int sum = 0;
                for (int j = i; j < n; ++j) {
                    sum += nums[j];  // 这步优化将时间复杂度从O(N*N*N)提高到O(N*N)
                    if (sum >= s) {
                        res = std::min(res, j - i + 1);
                        break; // 以i开始的连续子串求和已经大于0，后面的循环无效，跳出当前循环
                    }
                }
            }
            return res == n + 1 ? 0 : res;
        }

        // 方法三，双指针滑动窗口, O(N)
        int minSubArrayLen_3e(int s, vector<int> &nums) {
            const int n = nums.size();
            int res = n + 1;
            int l = 0;
            int r = -1;  // 循环不变量，[l...r]保存子串
            int sum = 0;
            while (l < n) {
                if (sum < s && r + 1 < n) {
                    sum += nums[++r];
                } else {
                    // r已经到底，即r == n-1
                    // 或者sum >= s
                    // 或者以上两者都满足
                    // ???如果 sum >= s，直接在这儿减掉一个nums[l]会不会导致有场景没有计入res
                    // 不会，出现上述情况不会走到else这个分支里面，会进行res计算,下次循环才跳入else中，和减去nums[l],且l递增
                    sum -= nums[l++];
                }
                if (sum >= s) {
                    res = std::min(res, r - l + 1);
                }
            }
            return res == n + 1 ? 0 : res;
        }

        // 方法四，双指针滑动窗口另一种写法, O(N)
        int minSubArrayLen_4e(int s, vector<int> &nums) {
            const int n = nums.size();
            int res = n + 1;
            int l = 0;
            int r = 0;  // 循环不变量，[l...r] 保存子串
            int sum = 0;
            while (r < n) {
                sum += nums[r];
                while (sum >= s) {
                    // ???如果nums[r] >> s,则递进到此会不会出现l累加到超过r的情况
                    // 不会，如果出现上述情况，l同样递进到r的位置，和重新变为0，也就是在下次循环中l和r都从原来r + 1的位置重新开始计算循环
                    res = std::min(res, r - l + 1);
                    sum -= nums[l++];
                }
                ++r;
            }
            return res == n + 1 ? 0 : res;
        }

        // 方法五，二分查找，O(N * LOGN)
        int minSubArrayLen(int s, vector<int> &nums) {
            const int n = nums.size();
            vector<int> sum(n + 1, 0); // sum[i]表示nums[0....i-1]的和
            for (int i = 1; i <= n; ++i) {
                sum[i] = sum[i - 1] + nums[i - 1];
            }

            int res = n + 1;
            for (int i = 1; i <= n; ++i) {
                int tasget = sum[i - 1] + s;
                auto iter = std::lower_bound(sum.cbegin(), sum.cend(), tasget);
                if (iter != sum.cend()) {
                    res = std::min(res, static_cast<int>(std::distance(sum.cbegin(), iter)) - (i - 1));
                }
            }
            return res == n + 1 ? 0 : res;
        }

        // 重写指针对撞方法
        int minSubArrayLen_review1(int s, vector<int> &nums) {
            const int n = nums.size();
            int l = 0;
            int r = 0;   // [l....r]存储子串
            int sum = 0;
            int res = n + 1;
            while (r < n) {
                sum += nums[r];
                while (sum >= s) {
                    res = std::min(res, r - l + 1);
                    sum -= nums[l++];
                }
                ++r;
            }
            return res == n + 1 ? 0 : res;
        }
    };