##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/2079.html

# 2079. Watering Plants (Medium)

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 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

Companies:

Related Topics:
Array

## Solution 1. Simulation

1. When we can water A[i], consume it water -= A[i] and increment i.
2. If we haven’t reached the last plant, add 2 * i to the answer; otherwise, add i.
3. Refill water. Go back to step 1 if i < N.
• // OJ: https://leetcode.com/problems/watering-plants/
// Time: O(N)
// Space: O(1)
class Solution {
public:
int wateringPlants(vector<int>& A, int C) {
int N = A.size(), ans = 0, water = C;
for (int i = 0; i < N; water = C) { // refill water after each round
for (; i < N && water - A[i] >= 0; ++i) water -= A[i]; // When we can water A[i], consume it and increment i.
ans += (i == N ? 1 : 2) * i; // If we haven't reached the last plant, add 2 * i to the answer; otherwise, add i.
}
return ans;
}
};

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

############

# 2079. Watering Plants
# https://leetcode.com/problems/watering-plants/

class Solution:
def wateringPlants(self, plants: List[int], capacity: int) -> int:
n = len(plants)
res = 0
curr = capacity

for i, x in enumerate(plants):
res += 1
curr -= x

if i + 1 < n and curr < plants[i + 1]:
res += i + 1 # go back to fill
res += i + 1 # go back to curr pos
curr = capacity

return res


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

• func wateringPlants(plants []int, capacity int) int {
ans, cap := 0, capacity
for i, x := range plants {
if cap >= x {
cap -= x
ans++
} else {
cap = capacity - x
ans += i*2 + 1
}
}
return ans
}

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


• impl Solution {
pub fn watering_plants(plants: Vec<i32>, capacity: i32) -> i32 {
let n = plants.len();
let mut ans = 0;
let mut water = capacity;
for i in 0..n {
if water < plants[i] {
ans += 2 * i + 1;
water = capacity - plants[i];
} else {
ans += 1;
water -= plants[i];
}
}
ans as i32
}
}



## Discuss

https://leetcode.com/problems/watering-plants/discuss/1589015/C%2B%2B-O(N)-One-Pass