LeetCode 1326. 灌溉花园的最少水龙头数目 (贪心 区间完全覆盖问题)

在 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
解释：即使打开所有水龙头，你也无法灌溉整个花园。
示例 3：

输入：n = 7, ranges = [1,2,1,0,2,1,0,1]
输出：3
示例 4：

输入：n = 8, ranges = [4,0,0,0,0,0,0,0,4]
输出：2
示例 5：

输入：n = 8, ranges = [4,0,0,0,4,0,0,0,4]
输出：1
 

提示：

1 <= n <= 10^4
ranges.length == n + 1
0 <= ranges[i] <= 100

 

题解：本题是一道典型的区间完全覆盖问题

所谓区间完全覆盖就是：

问题描述：给定一个长度为m的区间，再给出n条线段的起点和终点（注意这里是闭区间），求最少使用多少条线段可以将整个区间完全覆盖。

求解思路：

（1）先将全部区间按左端点递增排序，若左端点相同则按右端点递减排序

（2）用一个变量记录已覆盖的区间的右端点，再从剩下的区间中去找左端点小于等于已覆盖的区间的右端点的区间， 选择右端点最大并且大于当前已覆盖到的区间右端点，重复以上操作直至覆盖整个区间；

（3）若所有区间用完还不能完全覆盖要求覆盖的区间，则说明覆盖失败

class Solution {
public:
    struct Sec
    {
        int l, r;
        Sec(int l, int r): l(l), r(r){}
    };

    int minTaps(int n, vector<int>& ranges)
    {
        vector<Sec> vec;
        for (int i = 0; i <= n; i++)
        {
            int l = max(0, i - ranges[i]);
            int r = min(n, i + ranges[i]);
            vec.emplace_back(l, r);
        }
        sort(vec.begin(), vec.end(),[&](Sec x, Sec y)
                {
                    if (x.l == y.l) return x.r > y.r;
                    return x.l < y.l;
                });
        int R = 0;
        int len = 0;
        int maxlen = 0;
        int i = 0;
        int j = 0;
        int ans = 0;
        while (len < n)
        {
            maxlen = 0;
            for (; i <= n; i++)
            {
                if (vec[i].l <= R)
                {
                    if ((vec[i].r - R) >= maxlen)
                    {
                        maxlen = (vec[i].r - R);
                        j = i;
                    }
                }
                else
                {
                    break;
                }
            }
            if (maxlen == 0)
            {
                return -1;
            }
            len += maxlen;
            ++ans;
            R = vec[j].r;
        }
        return ans;
    }
};