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

提示：

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/minimum-number-of-taps-to-open-to-water-a-garden

题目分析

第一感使用贪心策略，优先选择覆盖范围最大的水龙头。

1. 计算出能够覆盖点i的水龙头的集合cover[i][n]
2. 在每个点的覆盖集合中，选择覆盖右端最远的水龙头，并记录右端的值，继续向右寻找
3. 如果不存在能够向右灌溉的水龙头且当前位置不为n，则返回-1

自己尝试写代码：

class Solution {
public:

    int minTaps(int n, vector<int>& ranges) {
        vector<vector<int> > cover(n+1); //初始化二维数组，列为n+1，行不固定
        int ans = 0;
        for(int i=0;i<=n;i++){
            //处理第i个水龙头
            for(int j=max(0,i-ranges[i]);j<=min(n,i+ranges[i]);j++){
                cover[j].push_back(i);
            }
        }

        for(int i=0;i<n;){
            int farthest=0;
            int flag=0;//标记能否继续向右灌溉
            //cout<<cover[i].size()<<endl;
            for(int j=0;j<cover[i].size();j++){
                //cout<<cover[i][j]<<endl;
                if(cover[i][j]+ranges[cover[i][j]]>farthest){
                    flag=1;
                    farthest=cover[i][j]+ranges[cover[i][j]];
                }
            }
            if(!flag) return -1;
            ans++;
            i=farthest;
            //cout<<i<<endl;
        }
        return ans;
    }
};

通过了样例，但是超出时间限制，猜测是因为存在双重循环

学习@lkaruga提供的题解,将标记退化为一维数组，使用指针向右查询，使空间和时间都得到了一定程度上的优化

class Solution {
public:

    int minTaps(int n, vector<int>& ranges) {
        vector<int> cover(n+1,0); //初始化n+1个0
        int ans = 0;
        for(int i=0;i<=n;i++){
            for(int j=max(i - ranges[i], 0);j<=min(i + ranges[i], n);j++){
                cover[j]=max(cover[i],min(i + ranges[i], n)); //更新每个结点的最右端
            }
        }

        for(int i=0;i<n;){
            //能否继续向右灌溉
            if(cover[i]>i) {
               i=cover[i]; 
               ans++;
            }
            else return -1;
        }
        return ans;
    }
};

官方示例代码：

class Solution {
public:
    int minTaps(int n, vector<int>& ranges) {
        int right[n + 1];
        memset(right, 0, sizeof(right));
        for (int i = 0; i <= n; ++i) {
            int r = ranges[i];
            if (i > r) right[i - r] = i + r; //这一步没有想明白，过几天再看看
            else right[0] = max(right[0], i + r);
        }

        int ans = 0, curR = 0, nextR = 0;
        for (int i = 0; i <= n; ++i) {
            if (i >= curR) {
                if (i > nextR) return -1;
                if (i < n) {
                    ++ans;
                    curR = max(right[i], nextR);
                }
            }
            nextR = max(nextR, right[i]);
        }
        return ans;
    }
};

总结

本题是典型的区间覆盖问题，使用指针向右遍历，贪心选择最远的即可。感觉难度不是特别大