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

         }

     }

 };

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

     }

 };