Minimum Number of Taps to Open to Water a Garden

Minimum Number of Taps to Open to Water a Garden - Problem

Imagine you're a smart irrigation system designer tasked with watering a rectangular garden efficiently! 🌱

You have a one-dimensional garden that stretches from point 0 to point n on the x-axis. Along this garden, there are n + 1 water taps positioned at every integer point: [0, 1, 2, ..., n].

Each tap has a specific watering range. The tap at position i can water the area from [i - ranges[i], i + ranges[i]] when turned on. For example, if ranges[2] = 3, then tap 2 can water the area from position -1 to position 5.

Your goal: Find the minimum number of taps you need to turn on to water the entire garden from position 0 to position n. If it's impossible to water the whole garden, return -1.

This is essentially an interval covering problem - you need to cover the interval [0, n] using the minimum number of available intervals (tap ranges).

Input & Output

example_1.py — Basic Case

$ Input: n = 5, ranges = [3,4,1,1,0,0]

› Output: 1

💡 Note: Tap at index 1 has range 4, covering area [1-4, 1+4] = [-3, 5]. Since we only need to cover [0, 5], this single tap is sufficient.

example_2.py — Multiple Taps Needed

$ Input: n = 3, ranges = [0,0,0,0]

› Output: -1

💡 Note: All taps have range 0, meaning each can only water its own position. Cannot cover the gaps between positions, making it impossible to water the entire garden.

example_3.py — Optimal Selection

$ Input: n = 7, ranges = [1,2,1,0,2,1,0,1]

› Output: 3

💡 Note: Optimal solution uses taps at indices 1, 4, and 6. Tap 1 covers [−1,3], tap 4 covers [2,6], and tap 6 covers [6,6], together covering [0,7].

Visualization

Tap to expand

Understanding the Visualization

Map Tap Ranges

Convert each tap's position and range into coverage intervals

Start from Beginning

Begin at position 0 and look for taps that can cover this position

Choose Greedily

Among valid taps, pick the one that extends coverage the furthest right

Advance Coverage

Move to the new coverage boundary and repeat until garden is fully covered

Key Takeaway

🎯 Key Insight: The greedy approach works because extending coverage as far as possible at each step minimizes the total number of taps needed. This transforms a complex optimization problem into a simple iterative process.

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n)

2^n subsets to check, each taking O(n) time to validate coverage

⚠ Quadratic Growth

Space Complexity

O(n)

Space to store current subset and coverage tracking

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁴
ranges.length == n + 1
0 ≤ ranges[i] ≤ 100
Garden coordinates are from 0 to n inclusive

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses a greedy algorithm to solve this interval coverage problem. At each step, select the tap that covers the current position and extends the furthest to the right. This ensures minimum taps while guaranteeing complete garden coverage in O(n²) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n × n)	O(n)	Try every possible combination of taps to find the minimum set
Greedy Interval Coverage	O(n²)	O(1)	Use greedy approach to select taps that extend coverage the furthest

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible subsets of taps (2^n combinations)
For each subset, check if it covers the entire garden [0, n]
Keep track of the minimum size subset that works
Return the minimum count, or -1 if no subset works

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all possible combinations of taps using bit manipulation

Check Coverage

For each subset, verify if it covers the entire garden

Track Minimum

Keep the smallest subset that provides complete coverage

Code -

solution.c — C

int numPointsInGarden(int n, int* ranges, int rangesSize) {
    int coversGarden(int mask, int n, int* ranges) {
        int covered[n + 1];
        memset(covered, 0, sizeof(covered));
        for (int i = 0; i <= n; i++) {
            if (mask & (1 << i)) {
                int left = (i - ranges[i] > 0) ? i - ranges[i] : 0;
                int right = (i + ranges[i] < n) ? i + ranges[i] : n;
                for (int j = left; j <= right; j++) {
                    covered[j] = 1;
                }
            }
        }
        for (int i = 0; i <= n; i++) {
            if (!covered[i]) return 0;
        }
        return 1;
    }
    
    int minTaps = INT_MAX;
    for (int mask = 1; mask < (1 << (n + 1)); mask++) {
        if (coversGarden(mask, n, ranges)) {
            int count = __builtin_popcount(mask);
            minTaps = (count < minTaps) ? count : minTaps;
        }
    }
    
    return (minTaps == INT_MAX) ? -1 : minTaps;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n)

2^n subsets to check, each taking O(n) time to validate coverage

⚠ Quadratic Growth

Space Complexity

O(n)

Space to store current subset and coverage tracking

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁴
ranges.length == n + 1
0 ≤ ranges[i] ≤ 100
Garden coordinates are from 0 to n inclusive

34.2K Views

Medium Frequency

~25 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler