Can Place Flowers LT605

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.

 Idea1. Count zeros, if there are K zeros between two 1s, it's (K-1)/2; if it's on the edge to the left or to the right, K/2, there is one 1; if no 1 at all, it's (K+1)/2;

Time complexity: O(N)

Space complexity: O(1)

class Solution {
    public boolean canPlaceFlowers(int[] flowerbed, int n) {
        int prev = -1;
        int zeros = 0;
        int result = 0;
        for(int num: flowerbed) {
            if(num == 0) {
                ++zeros;
            }
            else {
                int k = 0;
                if(prev == -1) {
                    k = zeros/2;
                } 
                else {
                    k = (zeros-1)/2;
                }
                result += k;
                zeros = 0;
                prev = num;
            }
        }
        if(prev == -1 ) {
            result += (zeros +1)/2;
        }
        else {
            result += zeros/2;
        }
        
        return result >= n;
    }
}

Idea 1.b smart idea by setting count = 1;

class Solution {
    public boolean canPlaceFlowers(int[] flowerbed, int n) {
        int zeros = 1;
        int result = 0;
        for(int i = 0; i < flowerbed.length; ++i) {
            if(flowerbed[i] == 0) {
                ++zeros;
            } 
            else {
                result += (zeros-1)/2;
                zeros = 0;
            }
        }
        
        if(zeros > 0) {
            result += zeros/2;
        }
        
        return result >= n;
    }
}

 

Idea 2. Simpler logic, check each zero if there is zeros ajacent to it, note the first element flowerbed[0] = 0 or the last element flowerbed[n-1] = 0.

Time complexity: O(N)

Space complexity: O(1)

class Solution {
    public boolean canPlaceFlowers(int[] flowerbed, int n) {
        int prev = 0;
        int result = 0;
        for(int i = 0; i < flowerbed.length; ++i) {
            if(prev == 0 && flowerbed[i] == 0 && (i == flowerbed.length-1 || flowerbed[i+1] == 0)) {
                ++result;
                prev = 1;
            }
            else {
                prev = flowerbed[i];
            }
        }
        return result >= n;
    }
}

Idea 2.b slightly optimise it, terminate the loop earlier if result == n reaches earlier.

Note check the result (result >= n) outside of the ++result loop, there might cases this loop is not executed, for example if n == 0, it would return false as ++result does not get executed.

class Solution {
    public boolean canPlaceFlowers(int[] flowerbed, int n) {
        int prev = 0;
        int result = 0;
        for(int i = 0; i < flowerbed.length; ++i) {
            if(prev == 0 && flowerbed[i] == 0 && (i == flowerbed.length-1 || flowerbed[i+1] == 0)) {
                ++result;
                prev = 1;    
            }
            else {
                prev = flowerbed[i];
            }
            
            if(result >= n) {
                    return true;
            }
        }
        return false;
    }
}