Array-Can Place Flowers

Description:

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:

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.

My Solution:

class Solution {
public boolean canPlaceFlowers(int[] flowerbed, int n) {
int count = 0;
int len = flowerbed.length;
if(len == 1){
return flowerbed[0] == 0 || n == 0;
}
for(int i = 0;i < len;i++){
if(flowerbed[i] == 0){
if(i == 0){
if(flowerbed[i + 1] == 0){
flowerbed[i] = 1;
count++;
i++;
}

af04
}else if(i == len - 1){
if(flowerbed[i - 1] == 0){
flowerbed[i] = 1;
count++;
}
}else{
if(flowerbed[i - 1] == 0 && flowerbed[i + 1] == 0){
flowerbed[i] = 1;
count++;
}
}
if(count >= n){
return true;
}
}
}
return false;
}
}

Better Solution:

class Solution {
public boolean canPlaceFlowers(int[] flowerbed, int n) {
int[] a = flowerbed;
if (a == null || a.length == 0) {
return true;
}
int rst = 0;
for (int i = 0; i < a.length; ++i) {
if (a[i] == 0) {
int prev = i == 0 ? 0 : a[i - 1];
int next = i == a.length - 1 ? 0 : a[i + 1];
if (prev == 0 && next == 0) {
rst++;
a[i] = 1;
}
}
}
return rst >= n;
}
}

Best Solution:

class Solution {
public boolean canPlaceFlowers(int[] flowerbed, int n) {
//int place = 0, noplace = 0;
int tmp = 0;
for(int i = 0; i < flowerbed.length; i++)
{
if(flowerbed[i] == 1)
{
i += 1;
}
else if(i < (flowerbed.length -1) && flowerbed[i+1] == 1)
{
i += 2;
}
else
{
tmp ++;
i++;
}
}
if(n <= tmp)
return true;
return false;

}
}