求选择最少的区间数目可以覆盖连续区间 [0,n]：跳跃游戏，视频拼接，灌溉花园的最少水龙头数目

世真

于 2023-02-21 20:11:20 发布

阅读量451

点赞数 1

分类专栏： LeetCode题解文章标签：游戏 leetcode 算法数据结构 c++

本文链接：https://blog.csdn.net/CegghnnoR/article/details/129149171

版权

LeetCode题解专栏收录该内容

8 篇文章 1 订阅

订阅专栏

选择最少区间数目覆盖区间。

贪心方法

假设有一个人想过桥，0 和 n 分别是河的两岸，一开始，人在 0

给你一些小区间，我们把这些区间视作桥。一开始我们肯定要选择包含 0 的区间，且要保证尽可能走得远。假如我们已经走到 4，那么下一条边该怎样选呢？

如此循环直到到达 n。修建桥的数量就是答案。

如果没有能够连接当前桥的区间，那么人不能到达对岸，这些区间不能完全覆盖整个数组。

题目：跳跃游戏

55. 跳跃游戏 - 力扣（Leetcode）

给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个下标。

示例 1：

输入：nums = [2,3,1,1,4]
输出：true
解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。

示例 2：

输入：nums = [3,2,1,0,4]
输出：false
解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。

提示：

1 <= nums.length <= 3 * 104
0 <= nums[i] <= 105

思路：

这道题可以看成是区间覆盖：

我们最后只要知道这些区间是否能完全覆盖整个数组。

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int n = nums.size();
        int cur = 0, next = 0; 				// cur记录当前已经建好的桥的右端点，next记录下一次建桥能到达的最远端点
        for (int i = 0; i < n - 1; ++i) {	// 从0到n-2，当i==n-1时，人已经在终点了，没必要再进入循环了
            next = max(next, i + nums[i]);  // 更新能到达的最远端点
            if (i == cur) {					// 如果人已经在建好的桥的最右端点了，则继续建桥
                if (i == next) return false;// 如果能到达的最远端点还在当前位置，说明无法建桥，不能覆盖整个数组
                cur = next;					// 建桥
            }
        }
        return true;
    }
};

题目：跳跃游戏 II

45. 跳跃游戏 II - 力扣（Leetcode）

给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。

每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处:

0 <= j <= nums[i]
i + j < n

返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。

示例 1:

输入: nums = [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。
     从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。

示例 2:

输入: nums = [2,3,0,1,4]
输出: 2

提示:

1 <= nums.length <= 104
0 <= nums[i] <= 1000
题目保证可以到达 nums[n-1]

思路：

这一题把求是否能完全覆盖改成了求完全覆盖最少需要的区间个数。也就是建桥次数。

class Solution {
public:
    int jump(vector<int>& nums) {
        int n = nums.size();
        int cur = 0, next = 0;
        int res = 0;
        for (int i = 0; i < n - 1; ++i) {
            next = max(next, i + nums[i]);
            if (i == cur) {
                cur = next;
                ++res;
            }
        }
        return res;
    }
};

题目：视频拼接

1024. 视频拼接 - 力扣（Leetcode）

你将会获得一系列视频片段，这些片段来自于一项持续时长为 time 秒的体育赛事。这些片段可能有所重叠，也可能长度不一。

使用数组 clips 描述所有的视频片段，其中 clips[i] = [starti, endi] 表示：某个视频片段开始于 starti 并于 endi 结束。

甚至可以对这些片段自由地再剪辑：

例如，片段 [0, 7] 可以剪切成 [0, 1] + [1, 3] + [3, 7] 三部分。

我们需要将这些片段进行再剪辑，并将剪辑后的内容拼接成覆盖整个运动过程的片段（[0, time]）。返回所需片段的最小数目，如果无法完成该任务，则返回 -1 。

示例 1：

输入：clips = [[0,2],[4,6],[8,10],[1,9],[1,5],[5,9]], time = 10
输出：3
解释：
选中 [0,2], [8,10], [1,9] 这三个片段。
然后，按下面的方案重制比赛片段：
将 [1,9] 再剪辑为 [1,2] + [2,8] + [8,9] 。
现在手上的片段为 [0,2] + [2,8] + [8,10]，而这些覆盖了整场比赛 [0, 10]。

示例 2：

输入：clips = [[0,1],[1,2]], time = 5
输出：-1
解释：
无法只用 [0,1] 和 [1,2] 覆盖 [0,5] 的整个过程。

示例 3：

输入：clips = [[0,1],[6,8],[0,2],[5,6],[0,4],[0,3],[6,7],[1,3],[4,7],[1,4],[2,5],[2,6],[3,4],[4,5],[5,7],[6,9]], time = 9
输出：3
解释： 
选取片段 [0,4], [4,7] 和 [6,9] 。

提示：

1 <= clips.length <= 100
0 <= starti <= endi <= 100
1 <= time <= 100

思路：

一个求最少区间覆盖的裸题。可以可以直接套模板。不过在这之前，需要预处理一个数组 mostR

mostR[i] 表示 i 端点所能到达的最远端点。

class Solution {
public:
    int videoStitching(vector<vector<int>>& clips, int time) {
        vector<int> mostR(time + 1);
        for (auto& e : clips) {
            if (e[0] >= 0 && e[0] <= time) mostR[e[0]] = max(mostR[e[0]], e[1]);
        }
        int cur = 0, next = 0;
        int res = 0;
        for (int i = 0; i < time; ++i) {
            next = max(next, mostR[i]);
            if (i == cur) {
                if (i == next) return -1;
                cur = next;
                ++res;
            }
        }
        return res;
    }
};

题目：灌溉花园的最少水龙头数目

1326. 灌溉花园的最少水龙头数目 - 力扣（Leetcode）

在 x 轴上有一个一维的花园。花园长度为 n，从点 0 开始，到点 n 结束。

花园里总共有 n + 1 个水龙头，分别位于 [0, 1, ..., n] 。

给你一个整数 n 和一个长度为 n + 1 的整数数组 ranges ，其中 ranges[i] （下标从 0 开始）表示：如果打开点 i 处的水龙头，可以灌溉的区域为 [i - ranges[i], i + ranges[i]] 。

请你返回可以灌溉整个花园的 最少水龙头数目 。如果花园始终存在无法灌溉到的地方，请你返回 -1 。

示例 1：

输入：n = 5, ranges = [3,4,1,1,0,0]
输出：1
解释：
点 0 处的水龙头可以灌溉区间 [-3,3]
点 1 处的水龙头可以灌溉区间 [-3,5]
点 2 处的水龙头可以灌溉区间 [1,3]
点 3 处的水龙头可以灌溉区间 [2,4]
点 4 处的水龙头可以灌溉区间 [4,4]
点 5 处的水龙头可以灌溉区间 [5,5]
只需要打开点 1 处的水龙头即可灌溉整个花园 [0,5] 。

示例 2：

输入：n = 3, ranges = [0,0,0,0]
输出：-1
解释：即使打开所有水龙头，你也无法灌溉整个花园。

提示：

1 <= n <= 104
ranges.length == n + 1
0 <= ranges[i] <= 100

思路：

和视频拼接类似，只是 mostR 数组的构建方法不同。

class Solution {
public:
    int minTaps(int n, vector<int>& ranges) {
        vector<int> mostR(n + 1);
        for (int i = 0; i <= n; ++i) {
            int r = ranges[i];
            if (i - r > 0) mostR[i - r] = i + r; // 一定是更大的，不需要取max
            else mostR[0] = max(mostR[0], i + r);
        }
        int res = 0, cur = 0, next = 0;
        for (int i = 0; i < n; ++i) {
            next = max(next, mostR[i]);
            if (i == cur) {
                if (next == i) return -1;
                cur = next;
                ++res;
            }
        }
        return res;
    }
};