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(n2),其中 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)。

  • 8
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

UestcXiye

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值