Leetcode209. 长度最小的子数组

Every day a Leetcode

题目来源：209. 长度最小的子数组

解法1：暴力

暴力法是最直观的方法。

初始化子数组的最小长度为无穷大，枚举数组 nums 中的每个下标作为子数组的开始下标，对于每个开始下标 i，需要找到大于或等于 i 的最小下标 j，使得下标范围 [i, j] 的元素和大于或等于 target，并更新子数组的最小长度（此时子数组的长度是 j−i+1）。

代码：

/*
 * @lc app=leetcode.cn id=209 lang=cpp
 *
 * [209] 长度最小的子数组
 */

// @lc code=start
class Solution
{
public:
    int minSubArrayLen(int target, vector<int> &nums)
    {
        // 特判
        if (nums.empty())
            return 0;
        int n = nums.size(), min_len = INT_MAX;
        for (int i = 0; i < n; i++)
        {
            int sum = 0;
            for (int j = i; j < n; j++)
            {
                sum += nums[j];
                if (sum >= target)
                {
                    int len = j - i + 1;
                    min_len = min(min_len, len);
                    break;
                }
            }
        }
        return min_len == INT_MAX ? 0 : min_len;
    }
};
// @lc code=end

结果：

复杂度分析：

时间复杂度：O(n²)，其中 n 是数组 nums 的长度。需要遍历每个下标作为子数组的开始下标，对于每个开始下标，需要遍历其后面的下标得到长度最小的子数组。

空间复杂度：O(1)。

解法2：前缀和 + 二分查找

为了使用二分查找，需要额外创建一个数组 preSum 用于存储数组 nums 的前缀和，其中 preSum[i] 表示从 nums[0] 到 nums[i−1] 的元素和。得到前缀和之后，对于每个开始下标 i，可通过二分查找得到大于或等于 i 的最小下标 bound，使得 preSum[bound]−preSum[i−1]≥target，并更新子数组的最小长度（此时子数组的长度是 static_cast<int>((bound - preSum.begin()) - (i - 1))）。

代码：

/*
 * @lc app=leetcode.cn id=209 lang=cpp
 *
 * [209] 长度最小的子数组
 */

// @lc code=start
class Solution
{
public:
    int minSubArrayLen(int target, vector<int> &nums)
    {
        // 特判
        if (nums.empty())
            return 0;
        int n = nums.size();
        vector<int> preSum(n + 1, 0);
        for (int i = 1; i <= n; i++)
            preSum[i] = preSum[i - 1] + nums[i - 1];
        int min_len = INT_MAX;
        for (int i = 1; i <= n; i++)
        {
            int cur_target = preSum[i - 1] + target;
            auto bound = lower_bound(preSum.begin(), preSum.end(), cur_target);
            if (bound != preSum.end())
                min_len = min(min_len, static_cast<int>((bound - preSum.begin()) - (i - 1)));
        }
        return min_len == INT_MAX ? 0 : min_len;
    }
};
// @lc code=end

结果：

复杂度分析：

时间复杂度：O(nlogn)，其中 n 是数组 nums 的长度。

空间复杂度：O(n)，其中 n 是数组 nums 的长度。额外创建数组 preSum 存储前缀和。

解法3：滑动窗口

定义两个指针 start 和 end 分别表示子数组（滑动窗口窗口）的开始位置和结束位置，维护变量 sum 存储子数组中的元素和（即从 nums[start] 到 nums[end] 的元素和）。

每一轮迭代，将 nums[end] 加到 sum，如果 sum≥target，则更新子数组的最小长度（此时子数组的长度是 end-start+1），然后将 nums[start] 从 sum 中减去并将 start 右移，直到 sum<target，在此过程中同样更新子数组的最小长度。在每一轮迭代的最后，将 end 右移。

代码：

/*
 * @lc app=leetcode.cn id=209 lang=cpp
 *
 * [209] 长度最小的子数组
 */

// @lc code=start

// 前缀和 + 二分查找

// class Solution
// {
// public:
//     int minSubArrayLen(int target, vector<int> &nums)
//     {
//         // 特判
//         if (nums.empty())
//             return 0;
//         int n = nums.size();
//         vector<int> preSum(n + 1, 0);
//         for (int i = 1; i <= n; i++)
//             preSum[i] = preSum[i - 1] + nums[i - 1];
//         int min_len = INT_MAX;
//         for (int i = 1; i <= n; i++)
//         {
//             int cur_target = preSum[i - 1] + target;
//             auto bound = lower_bound(preSum.begin(), preSum.end(), cur_target);
//             if (bound != preSum.end())
//                 min_len = min(min_len, static_cast<int>((bound - preSum.begin()) - (i - 1)));
//         }
//         return min_len == INT_MAX ? 0 : min_len;
//     }
// };

// 滑动窗口

class Solution
{
public:
    int minSubArrayLen(int target, vector<int> &nums)
    {
        // 特判
        if (nums.empty())
            return 0;
        int n = nums.size();
        int min_len = INT_MAX;
        int sum = 0, start = 0, end = 0;
        while (end < n)
        {
            sum += nums[end];
            while (sum >= target)
            {
                int len = end - start + 1;
                min_len = min(min_len, len);
                sum -= nums[start];
                start++;
            }
            end++;
        }
        return min_len == INT_MAX ? 0 : min_len;
    }
};
// @lc code=end

结果：

时间复杂度：O(n)，其中 n 是数组 nums 的长度。指针 start 和 end 最多各移动 n 次。

空间复杂度：O(1)。