Can Place Flowers LeetCode 605 Guide

LeetCode 605 — Can Place Flowers gives you a flowerbed array of 0s and 1s, where 1 means a flower is already planted and 0 means the plot is empty. You are also given an integer n representing the number of new flowers you want to plant. You must return true if you can plant all n flowers without placing any two flowers in adjacent plots.

The adjacency constraint means that if you plant at position i, both position i-1 and position i+1 must remain empty. The original flowers already in the bed must also be respected — you cannot plant next to an existing 1.

This problem is a classic easy-level greedy puzzle that tests whether you can reason about local decisions and their global impact. It appears frequently in introductory algorithm courses and as a warm-up in real interviews.

The greedy strategy is to scan the flowerbed from left to right and plant a flower at every valid position you encounter. A position i is valid if three conditions hold: flowerbed[i] is 0, the left neighbor (flowerbed[i-1]) is 0 or i equals 0, and the right neighbor (flowerbed[i+1]) is 0 or i equals the last index.

When you find a valid position, plant immediately: set flowerbed[i] = 1 and increment your count. Then continue scanning. If your count reaches n at any point, return true early. After the full scan, return count >= n.

The reason greedy works here is subtle but important. Planting as early as possible never prevents a future flower from being placed. If you skip a valid position and plant later instead, you can only do equal or worse — you gain nothing by waiting. The earliest valid spot is both locally and globally optimal.

The algorithm is a single linear pass with a counter. Initialize count = 0 and iterate over every index i from 0 to len(flowerbed) - 1. At each index, evaluate the three conditions in sequence. If all three pass, plant and increment. Return early as soon as count reaches n.

After the loop, return whether count >= n. This handles the edge case where n is 0 — you never need to plant anything, so the answer is immediately true (the loop never runs, count stays 0, and 0 >= 0 is true).

This approach modifies the flowerbed array in-place, which is allowed by the problem. If you need to preserve the original input, make a copy first. The in-place modification is what makes the adjacency check correct for the next position.

The first and last positions need special treatment because they have only one neighbor instead of two. Position 0 has no left neighbor, so treat the imaginary left neighbor as 0 — meaning it is always empty. Position len-1 has no right neighbor, so treat the imaginary right neighbor as 0 as well.

In code, this translates to two short-circuit conditions. For the left neighbor: (i == 0 or flowerbed[i-1] == 0). For the right neighbor: (i == len-1 or flowerbed[i+1] == 0). These expressions evaluate to true at boundaries without any index-out-of-bounds errors.

This boundary logic is the most common source of bugs in solutions to this problem. Missing a boundary check leads to index errors or incorrect results at the edges of the array. Always verify your solution with a single-element flowerbed like [0] with n=1.

Consider flowerbed = [1, 0, 0, 0, 1] with n = 1. We scan left to right. Position 0: flowerbed[0] = 1, skip. Position 1: flowerbed[1] = 0, left neighbor = flowerbed[0] = 1 (not 0), skip. Position 2: flowerbed[2] = 0, left = flowerbed[1] = 0, right = flowerbed[3] = 0 — all conditions pass! Plant here: set flowerbed[2] = 1, count = 1. Since count >= n (1 >= 1), return true immediately.

Now try flowerbed = [1, 0, 0, 0, 1] with n = 2. Position 2 plants as above, count = 1. Position 3: left = flowerbed[2] = 1 (just planted), skip. Position 4: flowerbed[4] = 1, skip. End of array, count = 1 < 2, return false.

Try flowerbed = [0, 0, 1, 0, 0] with n = 1. Position 0: current = 0, no left (treat as 0), right = flowerbed[1] = 0 — plant! count = 1 >= 1, return true. This shows how left boundary handling allows position 0 to be planted when the next cell is empty.

In Python: def canPlaceFlowers(flowerbed, n): for i in range(len(flowerbed)): if flowerbed[i]==0 and (i==0 or flowerbed[i-1]==0) and (i==len(flowerbed)-1 or flowerbed[i+1]==0): flowerbed[i]=1; n-=1; if n<=0: return True; return n<=0. Time complexity: O(n) — single pass. Space complexity: O(1) — no extra data structures, modifies input in-place.

In Java: public boolean canPlaceFlowers(int[] flowerbed, int n) { for (int i = 0; i < flowerbed.length; i++) { if (flowerbed[i]==0 && (i==0 || flowerbed[i-1]==0) && (i==flowerbed.length-1 || flowerbed[i+1]==0)) { flowerbed[i]=1; n--; if (n<=0) return true; } } return n<=0; }. The early return keeps the loop short-circuit when enough flowers are placed.

Both implementations decrement n directly instead of maintaining a separate counter — this simplifies the final check to n <= 0. The pattern is identical across languages: single for loop, three conditions, in-place update, early exit.

Can Place Flowers belongs to a family of greedy array problems where you scan linearly and make locally optimal decisions. Kids With the Greatest Number of Candies (LeetCode 1431) asks which kids can have the most candies if you give them extra — a simple one-pass maximum comparison. Merge Strings Alternately (LeetCode 1768) interleaves two strings character by character — trivial greedy with two pointers.

Greatest Common Divisor of Strings (LeetCode 1071) uses a mathematical greedy: check if the concatenation in both orders is equal, then return the GCD-length prefix. These problems share the theme of scanning or combining arrays with a local rule that produces the global optimum without backtracking.

Building fluency with this greedy array family helps you recognize when a problem can be solved in a single pass. The signal is usually: each decision affects only nearby elements, planting/choosing early is never worse than waiting, and no global state is needed beyond a counter. Can Place Flowers is the canonical example of this pattern.