力扣贪心 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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-number-of-taps-to-open-to-water-a-garden
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

Java:

class Solution {
    class Segment{
        int left, right;
        int num;
        Segment(int l, int r, int s){
            left = l;
            right = r;
            num = s;
        }
        public int getLeft(){
            return left;
        }
        public void setLeft(int left){
            this.left = left;
        }

        public int getRight(){
            return this.right;
        }
        public void setRight(int right){
            this.right = right;
        }

        public int getNum(){
            return this.num;
        }
        public void setNum(int num){
            this.num = num;
        }
    }
    public int minTaps(int n, int[] ranges) {
        //int dp[] = new dp[n+1];
        ArrayList<Segment> arrayList = new ArrayList<Segment>();
        for(int i = 0; i <= n; i++){
            int l = i - ranges[i] < 0 ? 0 : i - ranges[i];
            int r = i + ranges[i] > n ? n : i + ranges[i];
            arrayList.add(new Segment(l,r,1));
        }
        arrayList.sort(new Comparator<Segment>() {
            @Override
            public int compare(Segment o1, Segment o2) {
                if (o1.getLeft() == o2.getLeft())
                    return o1.getRight()-o2.getRight();
                return o1.getLeft()-o2.getLeft();
            }
        });
        // for(Segment s:arrayList){
        //     System.out.println(s.getLeft()+":"+s.getRight());
        // }
        // return 1;
        if(arrayList.get(0).getLeft() != 0)
            return -1;
        if(arrayList.get(0).getRight()==n)
            return 1;
        int f = 11000;
        for(int i = 1 ; i <= n; i++){
            Segment o1 = arrayList.get(i);
            int left = o1.getLeft();
            int right = o1.getRight();
            int num = o1.getNum();
            int s = -1;
            if(left == 0){
                if(right == n){
                    f = 1;
                }
                continue;
            }
            num = 11000;
            for(int j = 0; j < i; j++){
                Segment o2 = arrayList.get(j);
                if(o2.getLeft()==0 && o2.getRight() >= left && right > o2.getRight() && o2.getNum()+1 < num){
                    num = o2.getNum()+1;
                    s = j;
                }
            }
            if(s != -1){
                o1.setLeft(0);
                o1.setNum(num);
                if(right == n)
                    f = f > num ? num : f;
            }
        }
        return f == 11000 ? -1 : f;
    }
}

c++

class Solution {
public:
    int minTaps(int n, vector<int>& ranges) {
        vector<int> prev(n + 1);
        iota(prev.begin(), prev.end(), 0);

        for (int i = 0; i <= n; ++i) {
            int l = max(i - ranges[i], 0);
            int r = min(i + ranges[i], n);
            prev[r] = min(prev[r], l);
        }

        vector<int> dp(n + 1, INT_MAX);
        dp[0] = 0;
        for (int i = 1; i <= n; ++i) {
            for (int j = prev[i]; j < i; ++j) {
                if (dp[j] != INT_MAX) {
                    dp[i] = min(dp[i], dp[j] + 1);
                }
            }
        }

        return (dp[n] == INT_MAX ? -1 : dp[n]);
    }
};