605. Can Place Flowers【easy】

605. Can Place Flowers【easy】

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.

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:

1. The input array won't violate no-adjacent-flowers rule.
2. The input array size is in the range of [1, 20000].
3. n is a non-negative integer which won't exceed the input array size.

错误解法：

 class Solution {
 public:
     bool canPlaceFlowers(vector<int>& flowerbed, int n) {
         int max = ;
         int temp = ;

         for (int i = ; i < flowerbed.size(); ++i)
         {
             if (flowerbed[i] == )
             {
                 temp++;
                 max = temp > max ? temp : max;
             }
             else
             {
                 temp = ;
             }
         }

         if ((max - ) % )
         {
             return ((max - ) /  +  >= n);
         }
         else
         {
             return ((max - ) /  >= n);
         }
     }
 };

想要用最长连续的0去求，调试了很久，但还是条件判断有问题，这种方法不妥！

参考大神们的解法，如下：

解法一：

 public class Solution {
     public boolean canPlaceFlowers(int[] flowerbed, int n) {
         int count = ;
         for(int i = ; i < flowerbed.length && count < n; i++) {
             if(flowerbed[i] == ) {
          //get next and prev flower bed slot values. If i lies at the ends the next and prev are considered as 0.
                int next = (i == flowerbed.length - ) ?  : flowerbed[i + ];
                int prev = (i == ) ?  : flowerbed[i - ];
                if(next ==  && prev == ) {
                    flowerbed[i] = ;
                    count++;
                }
             }
         }

         return count == n;
     }
 }

解法二：

 public boolean canPlaceFlowers(int[] flowerbed, int n) {
     for (int idx = ; idx < flowerbed.length && n > ; idx ++)
         if (flowerbed [idx] ==  && (idx ==  || flowerbed [idx - ] == ) && (idx == flowerbed.length -  || flowerbed [idx + ] == )) {
             n--;
             flowerbed [idx] = ;
         }
     return n == ;
 }

解法一和解法二都需要随时更新原来数组的状态

解法三：

 class Solution {
 public:
     bool canPlaceFlowers(vector<int>& flowerbed, int n) {
         flowerbed.insert(flowerbed.begin(),);
         flowerbed.push_back();
         for(int i = ; i < flowerbed.size()-; ++i)
         {
             if(flowerbed[i-] + flowerbed[i] + flowerbed[i+] == )
             {
                 --n;
                 ++i;
             }

         }
         return n <=;
     }
 };

不更新原来数组的值，通过多移下标来实现