Can Place Flowers

Can Place Flowers - Problem

Array Greedy Easy

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.

Given an integer array flowerbed containing 0's and 1's, where 0 means empty and 1 means not empty, and an integer n, return true if n new flowers can be planted in the flowerbed without violating the no-adjacent-flowers rule and false otherwise.

Input & Output

Example 1 — Basic Case

$ Input: flowerbed = [1,0,0,0,1], n = 1

› Output: true

💡 Note: We can plant 1 flower at position 2. Position 1 is invalid (adjacent to flower at 0), position 3 is invalid (adjacent to flower at 4), but position 2 has empty neighbors on both sides.

Example 2 — Not Enough Space

$ Input: flowerbed = [1,0,0,0,1], n = 2

› Output: false

💡 Note: We can only plant 1 flower at position 2. There's no second valid position that doesn't violate the adjacency rule, so we cannot plant 2 flowers.

Example 3 — Edge Case All Empty

$ Input: flowerbed = [0,0,0], n = 2

› Output: true

💡 Note: We can plant flowers at positions 0 and 2. Position 1 cannot be used because it would be adjacent to both planted flowers.

Constraints

1 ≤ flowerbed.length ≤ 2 × 10⁴
flowerbed[i] is 0 or 1
There are no two adjacent flowers in flowerbed
0 ≤ n ≤ flowerbed.length

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 in LinkedIn 8

The key insight is to use a greedy approach - plant flowers whenever we find a valid empty spot. The greedy strategy works because planting earlier never prevents optimal future placements. Best approach achieves O(n) time and O(1) space.

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(C(m,n) × n) Space: O(n)

This approach generates all possible combinations of placing n flowers in the empty plots and checks if any combination satisfies the no-adjacent rule. We use backtracking to try every possibility.

Greedy - Plant Whenever Possible

⏱️ Time: O(n) Space: O(1)

This greedy approach scans the flowerbed from left to right. Whenever we find an empty plot that doesn't violate the adjacency rule, we immediately plant a flower there. This works because planting as early as possible never prevents future optimal placements.

Brute Force - Try All Combinations — Algorithm Steps

Step 1: Find all empty positions (0s) in the flowerbed
Step 2: Generate all combinations of n positions from empty positions
Step 3: For each combination, check if no two positions are adjacent
Step 4: Return true if any valid combination exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Empty Spots

Identify all positions with 0s

Generate Combinations

Try all ways to choose n positions

Validate

Check if placement violates adjacency rule

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

bool isValidPlacement(int* flowerbed, int size, int* positions, int posCount) {
    int* temp = malloc(size * sizeof(int));
    memcpy(temp, flowerbed, size * sizeof(int));
    
    for (int i = 0; i < posCount; i++) {
        temp[positions[i]] = 1;
    }
    
    for (int i = 0; i < size; i++) {
        if (temp[i] == 1) {
            if ((i > 0 && temp[i-1] == 1) || (i < size-1 && temp[i+1] == 1)) {
                free(temp);
                return false;
            }
        }
    }
    
    free(temp);
    return true;
}

bool hasCombination(int* emptyPos, int emptyCount, int n, int start, int* current, int currentSize, int* flowerbed, int fbSize) {
    if (currentSize == n) {
        return isValidPlacement(flowerbed, fbSize, current, currentSize);
    }
    
    for (int i = start; i < emptyCount; i++) {
        current[currentSize] = emptyPos[i];
        if (hasCombination(emptyPos, emptyCount, n, i + 1, current, currentSize + 1, flowerbed, fbSize)) {
            return true;
        }
    }
    
    return false;
}

bool solution(int* flowerbed, int size, int n) {
    if (n == 0) return true;
    
    int* emptyPositions = malloc(size * sizeof(int));
    int emptyCount = 0;
    
    for (int i = 0; i < size; i++) {
        if (flowerbed[i] == 0) {
            emptyPositions[emptyCount++] = i;
        }
    }
    
    int* current = malloc(n * sizeof(int));
    bool result = hasCombination(emptyPositions, emptyCount, n, 0, current, 0, flowerbed, size);
    
    free(emptyPositions);
    free(current);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int flowerbed[1000];
    int size = 0;
    char* ptr = strchr(line, '[') + 1;
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        flowerbed[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    fgets(line, sizeof(line), stdin);
    int n = atoi(line);
    
    bool result = solution(flowerbed, size, n);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(m,n) × n)

Generate C(m,n) combinations where m is empty plots, check each combination takes O(n)

✓ Linear Growth

Space Complexity

O(n)

Store current combination and recursion stack depth

✓ Linear Space

34.0K Views

Medium Frequency

~15 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler