Watering Plants II - Practice Coding Problems

Watering Plants II - Problem

Imagine Alice and Bob are gardening enthusiasts who want to efficiently water n plants arranged in a straight row. The plants are numbered from 0 to n-1 from left to right, and each plant has specific water requirements.

The Challenge: They have their own watering cans with different capacities and follow a unique watering strategy:

🌱 Alice starts from the leftmost plant (index 0) and moves right
🌿 Bob starts from the rightmost plant (index n-1) and moves left
⏱️ They water plants simultaneously at the same pace
💧 If they don't have enough water for a plant, they must refill first (instantaneous)
🤝 If they meet at the same plant, whoever has more water waters it (Alice wins ties)

Goal: Calculate the total number of refills needed to water all plants.

Input: Array plants[] where plants[i] is water needed for plant i, and integers capacityA and capacityB for Alice's and Bob's can capacities.

Output: Total number of refills required.

Input & Output

example_1.py — Basic Case

$ Input: plants = [2,2,3,3], capacityA = 5, capacityB = 5

› Output: 1

💡 Note: Alice waters plants 0,1 (uses 4 water, has 1 left). Bob waters plant 3 (uses 3 water, has 2 left). They meet at plant 2 needing 3 water. Alice has 1, Bob has 2, so Bob waters it but needs to refill first. Total refills: 1.

example_2.py — No Refills Needed

$ Input: plants = [1,2,4,4,5], capacityA = 6, capacityB = 5

› Output: 2

💡 Note: Alice: waters plant 0 (5 left), plant 1 (3 left). Bob: waters plant 4, needs refill (refill #1), then plant 3 (1 left). They meet at plant 2 needing 4 water. Alice has 3, Bob has 1, so Alice needs refill #2.

example_3.py — Single Plant Edge Case

$ Input: plants = [5], capacityA = 10, capacityB = 8

› Output: 0

💡 Note: Only one plant. Alice and Bob meet at plant 0. Alice has 10 water, Bob has 8 water. Alice has more so she waters the plant needing 5 water. No refills needed.

Constraints

n == plants.length
1 ≤ n ≤ 10⁵
1 ≤ plants[i] ≤ 10⁶
plants[i] ≤ capacityA, capacityB ≤ 10⁶
Each plant can be watered by at least one person

Visualization

Tap to expand

Understanding the Visualization

Setup Phase

Alice starts at leftmost plant, Bob at rightmost, both with full cans

Watering Phase

They move toward each other, refilling when needed for each plant

Meeting Phase

When they reach the same plant, the one with more water handles it

Completion

Count total refills needed throughout the entire process

Key Takeaway

🎯 Key Insight: The two-pointer approach efficiently simulates the watering process by having Alice and Bob work from opposite ends, only requiring special handling when they meet at the same plant.

Asked in

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

The optimal solution uses two pointers starting from opposite ends of the plants array. Alice moves left-to-right, Bob moves right-to-left, and we simulate their watering process. The key insight is handling the meeting point where they reach the same plant - whoever has more water (Alice wins ties) should water it. Time complexity is O(n) with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n)	O(1)	Simulate every step with detailed tracking of both Alice and Bob
Optimized Two Pointers (Optimal)	O(n)	O(1)	Efficient simulation using two pointers moving towards each other

Brute Force Simulation — Algorithm Steps

Initialize Alice at position 0, Bob at position n-1
Track current water levels for both
For each step, check if they can water their current plant
Handle refills when water is insufficient
Handle conflicts when they meet at same plant
Continue until all plants are watered

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Alice starts at left, Bob at right, both with full cans

Check Water

Before watering, check if they have enough water

Refill if Needed

Refill and increment counter if water insufficient

Water Plant

Water the plant and move to next position

Handle Meeting

When they meet, determine who waters the plant

Code -

solution.c — C

#include <stdio.h>

int minimumRefill(int* plants, int plantsSize, int capacityA, int capacityB) {
    int alicePos = 0, bobPos = plantsSize - 1;
    int aliceWater = capacityA, bobWater = capacityB;
    int refills = 0;
    
    while (alicePos <= bobPos) {
        if (alicePos == bobPos) {
            int waterNeeded = plants[alicePos];
            if (aliceWater >= bobWater) {
                if (aliceWater < waterNeeded) {
                    refills++;
                    aliceWater = capacityA;
                }
            } else {
                if (bobWater < waterNeeded) {
                    refills++;
                    bobWater = capacityB;
                }
            }
            break;
        }
        
        if (aliceWater < plants[alicePos]) {
            refills++;
            aliceWater = capacityA;
        }
        aliceWater -= plants[alicePos];
        alicePos++;
        
        if (bobWater < plants[bobPos]) {
            refills++;
            bobWater = capacityB;
        }
        bobWater -= plants[bobPos];
        bobPos--;
    }
    
    return refills;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each plant exactly once, so linear time complexity

✓ Linear Growth

Space Complexity

O(1)

Only storing positions, water levels, and refill count

✓ Linear Space

28.6K Views

Medium Frequency

~15 min Avg. Time

892 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler