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

plant is located at ^{th}`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 `i`

plant needs, and an integer ^{th}`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 = 5Output:14Explanation: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 = 4Output:30Explanation: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 = 8Output:49Explanation: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] <= 10`

^{6}`max(plants[i]) <= capacity <= 10`

^{9}

**Solution: Simulation**

Time complexity: O(n)

Space complexity: O(1)

## C++

1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
// Author: Huahua class Solution { public: int wateringPlants(vector<int>& plants, int capacity) { const int n = plants.size(); int ans = 0; for (int i = 0, c = capacity; i < n; c -= plants[i++], ++ans) { if (c >= plants[i]) continue; ans += i * 2; c = capacity; } return ans; } }; |

请尊重作者的劳动成果，转载请注明出处！花花保留对文章／视频的所有权利。

如果您喜欢这篇文章／视频，欢迎您捐赠花花。

If you like my articles / videos, donations are welcome.

## Be First to Comment