LeetCode 2079. Watering Plants Solution in Java, C++, Python & More | Explanation + Code

Description

You want to water n plants in your garden with a watering can. The plants are arranged in a row and are labeled from 0 to n - 1 from left to right where the ith plant is located at x = i. There is a river at x = -1 that you can refill your watering can at.

Each plant needs a specific amount of water. You will water the plants in the following way:

• Water the plants in order from left to right.
• After watering the current plant, if you do not have enough water to completely water the next plant, return to the river to fully refill the watering can.
• You cannot refill the watering can early.

You are initially at the river (i.e., x = -1). It takes one step to move one unit on the x-axis.

Given a 0-indexed integer array plants of n integers, where plants[i] is the amount of water the ith plant needs, and an integer capacity representing the watering can capacity, return the number of steps needed to water all the plants.

 

Example 1:

Input: plants = [2,2,3,3], capacity = 5
Output: 14
Explanation: Start at the river with a full watering can:
- Walk to plant 0 (1 step) and water it. Watering can has 3 units of water.
- Walk to plant 1 (1 step) and water it. Watering can has 1 unit of water.
- Since you cannot completely water plant 2, walk back to the river to refill (2 steps).
- Walk to plant 2 (3 steps) and water it. Watering can has 2 units of water.
- Since you cannot completely water plant 3, walk back to the river to refill (3 steps).
- Walk to plant 3 (4 steps) and water it.
Steps needed = 1 + 1 + 2 + 3 + 3 + 4 = 14.

Example 2:

Input: plants = [1,1,1,4,2,3], capacity = 4
Output: 30
Explanation: Start at the river with a full watering can:
- Water plants 0, 1, and 2 (3 steps). Return to river (3 steps).
- Water plant 3 (4 steps). Return to river (4 steps).
- Water plant 4 (5 steps). Return to river (5 steps).
- Water plant 5 (6 steps).
Steps needed = 3 + 3 + 4 + 4 + 5 + 5 + 6 = 30.

Example 3:

Input: plants = [7,7,7,7,7,7,7], capacity = 8
Output: 49
Explanation: You have to refill before watering each plant.
Steps needed = 1 + 1 + 2 + 2 + 3 + 3 + 4 + 4 + 5 + 5 + 6 + 6 + 7 = 49.

 

Constraints:

• n == plants.length
• 1 <= n <= 1000
• 1 <= plants[i] <= 106
• max(plants[i]) <= capacity <= 109

Solutions

Solution 1: Simulation

We can simulate the process of watering the plants. We use a variable water to represent the current amount of water in the watering can, initially water = capacity.

We traverse the plants. For each plant:

• If the current amount of water in the watering can is enough to water this plant, we move forward one step, water this plant, and update water = water - plants[i].
• Otherwise, we need to return to the river to refill the watering can, walk back to the current position, and then move forward one step. The number of steps we need is i × 2 + 1. Then we water this plant and update water = capacity - plants[i].

Finally, return the total number of steps.

The time complexity is O(n), where n is the number of plants. The space complexity is O(1).

PythonJavaC++GoTypeScriptRustC

class Solution: def wateringPlants(self, plants: List[int], capacity: int) -> int: ans, water = 0, capacity for i, p in enumerate(plants): if water >= p: water -= p ans += 1 else: water = capacity - p ans += i * 2 + 1 return ans(code-box)

class Solution { public int wateringPlants(int[] plants, int capacity) { int ans = 0, water = capacity; for (int i = 0; i < plants.length; ++i) { if (water >= plants[i]) { water -= plants[i]; ans += 1; } else { water = capacity - plants[i]; ans += i * 2 + 1; } } return ans; } }(code-box)

class Solution { public: int wateringPlants(vector<int>& plants, int capacity) { int ans = 0, water = capacity; for (int i = 0; i < plants.size(); ++i) { if (water >= plants[i]) { water -= plants[i]; ans += 1; } else { water = capacity - plants[i]; ans += i * 2 + 1; } } return ans; } };(code-box)

func wateringPlants(plants []int, capacity int) (ans int) { water := capacity for i, p := range plants { if water >= p { water -= p ans++ } else { water = capacity - p ans += i*2 + 1 } } return }(code-box)

function wateringPlants(plants: number[], capacity: number): number { let [ans, water] = [0, capacity]; for (let i = 0; i < plants.length; ++i) { if (water >= plants[i]) { water -= plants[i]; ++ans; } else { water = capacity - plants[i]; ans += i * 2 + 1; } } return ans; }(code-box)

impl Solution { pub fn watering_plants(plants: Vec<i32>, capacity: i32) -> i32 { let mut ans = 0; let mut water = capacity; for (i, &p) in plants.iter().enumerate() { if water >= p { water -= p; ans += 1; } else { water = capacity - p; ans += (i as i32) * 2 + 1; } } ans } }(code-box)

int wateringPlants(int* plants, int plantsSize, int capacity) { int ans = 0, water = capacity; for (int i = 0; i < plantsSize; ++i) { if (water >= plants[i]) { water -= plants[i]; ans += 1; } else { water = capacity - plants[i]; ans += i * 2 + 1; } } return ans; }(code-box)