---
description: 可以反向思考，例如與其找沒種的 0，不如判斷有種過的 1 ，這樣可以更可以簡潔寫出各種狀況
---

# # 605. Can Place Flowers

[LeetCode](https://leetcode.com/problems/can-place-flowers/)

```
Suppose you have a long flowerbed in which some of the plots are planted and some are not. However, flowers cannot be planted in adjacent plots - they would compete for water and both would die.

Given a flowerbed (represented as an array containing 0 and 1, where 0 means empty and 1 means not empty), 
and a number n, return if n new flowers can be planted in it without violating the no-adjacent-flowers rule.

input: arr = [1,0,0, ...]  1 代表有種花 0 代表沒種花, n 代表新花數量
output: 回傳心花是否可以種完

關鍵是不能種相鄰的花 
```

```
Example 1:
Input: flowerbed = [1,0,0,0,1], n = 1
Output: True
Example 2:
Input: flowerbed = [1,0,0,0,1], n = 2
Output: False
Note:
The input array won't violate no-adjacent-flowers rule.
The input array size is in the range of [1, 20000].
n is a non-negative integer which won't exceed the input array size.

/**
 * @param {number[]} flowerbed
 * @param {number} n
 * @return {boolean}
 */
var canPlaceFlowers = function(flowerbed, n) {}
```

### Edge Case

* \[0], \[0, 1] 之類邊界值

### 怎麼解

其實很單純我卻想很久邊界值怎麼處理，其實只要判斷前後跟自己是不是 1 ，都是就跳過，不是就代表可以種花

### Code

```
var canPlaceFlowers = function(flowerbed, n) {
let len = flowerbed.length;
 let plotsNums = 0;
 for(let i=0; i<len; i+=1){
  
   if(flowerbed[i]===1 || flowerbed[i+1] ===1 || flowerbed[i-1] ===1){
    // do nothing
   }else{
    plotsNums++;
    flowerbed[i] = 1;
   }

 }
 return plotsNums >= n
};
faster than 60.20%
```

### 如何改進

後來看到一個更容易理解就是前後都加 0&#x20;

```
var canPlaceFlowers = function(flowerbed, n) {
    flowerbed.unshift(0);
    flowerbed.push(0);
    for(let i=1;i<flowerbed.length;i++) {
        if(flowerbed[i]===0&&flowerbed[i-1]===0&&flowerbed[i+1]===0) {
            n--;
            flowerbed[i]=1;
        }
    }
    return n<=0;
};
// faster than 90.20%
```
