Flower Planting With No Adjacent - Practice Coding Problems

Flower Planting With No Adjacent - Problem

You are a landscape designer tasked with creating a beautiful garden arrangement! You have n gardens labeled from 1 to n, connected by bidirectional paths. Your goal is to plant one of 4 types of flowers (numbered 1, 2, 3, or 4) in each garden.

Here's the challenge: no two gardens connected by a path can have the same type of flower. Think of it as a graph coloring problem where you need to ensure adjacent nodes have different colors!

The good news? Each garden has at most 3 connecting paths, and since you have 4 flower types available, a solution is always guaranteed to exist.

Input: An integer n (number of gardens) and an array paths where paths[i] = [x_i, y_i] represents a bidirectional path between gardens x_i and y_i.

Output: An array answer where answer[i] is the type of flower (1-4) planted in the (i+1)th garden.

Input & Output

example_1.py — Basic Path Chain

$ Input: n = 3, paths = [[1,2],[2,3]]

› Output: [1,2,1]

💡 Note: Gardens 1 and 3 can use the same flower (1) since they're not connected. Garden 2 needs a different flower (2) from both neighbors.

example_2.py — Triangle Graph

$ Input: n = 4, paths = [[1,2],[1,3],[2,4]]

› Output: [1,2,2,1]

💡 Note: Garden 1 uses flower 1, its neighbors (2,3) must use different flowers. Garden 4 only connects to 2, so it can reuse flower 1.

example_3.py — Single Garden

$ Input: n = 1, paths = []

› Output: [1]

💡 Note: With no connections, the single garden can use any flower type. We choose type 1.

Constraints

1 ≤ n ≤ 10⁴
0 ≤ paths.length ≤ 2 * 10⁴
paths[i].length == 2
1 ≤ x_i, y_i ≤ n
Each garden has at most 3 paths coming into or leaving it
x_i ≠ y_i
It is guaranteed an answer exists

Visualization

Tap to expand

Understanding the Visualization

Map the Neighborhood

Build adjacency list showing which gardens are connected by paths

Visit Each Garden

Go through gardens 1, 2, 3, ... in order

Check Neighbors

For current garden, see which flower types its neighbors already use

Pick First Available

Choose the lowest numbered flower type that neighbors don't use

Guaranteed Success

Since max neighbors = 3 and available flowers = 4, always find one

Key Takeaway

🎯 Key Insight: Since each garden has ≤ 3 neighbors and we have 4 flower types, greedy assignment always finds a valid color without backtracking!

Asked in

G Google 45 f Facebook 38 a Amazon 32 ⊞ Microsoft 28

This is a graph coloring problem where we need to assign one of 4 flower types to each garden such that no adjacent gardens have the same type. The key insight is that since each garden has at most 3 neighbors and we have 4 colors available, a greedy approach always works. We can build the adjacency list once, then for each garden, track which colors its already-colored neighbors use and pick the first available color. This gives us O(n + m) time complexity where m is the number of paths.

Common Approaches

Approach	Time	Space	Notes
✓ Naive Graph Coloring	O(n * 4 * avg_degree)	O(n + m)	Try each color for each garden and check all neighbors repeatedly
Greedy Graph Coloring (Optimal)	O(n + m)	O(n + m)	Build adjacency list once, then greedily assign the first available color to each garden

Naive Graph Coloring — Algorithm Steps

Build adjacency list from paths
For each garden from 1 to n:
Try flower types 1, 2, 3, 4 in order
For each type, check all neighbors to see if they use this type
Choose the first valid type found
Continue to next garden

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list from paths

Try Colors

For each garden, try colors 1-4

Check Neighbors

Verify no neighbor uses the same color

Assign Color

Choose first valid color found

Code -

solution.c — C

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

int* gardenNoAdj(int n, int** paths, int pathsSize, int* returnSize) {
    // Build adjacency list using arrays
    int** graph = (int**)malloc((n + 1) * sizeof(int*));
    int* graphSize = (int*)calloc(n + 1, sizeof(int));
    
    for (int i = 0; i <= n; i++) {
        graph[i] = (int*)malloc(3 * sizeof(int)); // max 3 neighbors
    }
    
    for (int i = 0; i < pathsSize; i++) {
        int x = paths[i][0], y = paths[i][1];
        graph[x][graphSize[x]++] = y;
        graph[y][graphSize[y]++] = x;
    }
    
    int* result = (int*)calloc(n, sizeof(int));
    *returnSize = n;
    
    for (int garden = 1; garden <= n; garden++) {
        for (int flower = 1; flower <= 4; flower++) {
            int valid = 1;
            for (int i = 0; i < graphSize[garden]; i++) {
                int neighbor = graph[garden][i];
                if (neighbor < garden && result[neighbor - 1] == flower) {
                    valid = 0;
                    break;
                }
            }
            if (valid) {
                result[garden - 1] = flower;
                break;
            }
        }
    }
    
    // Free memory
    for (int i = 0; i <= n; i++) free(graph[i]);
    free(graph);
    free(graphSize);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * 4 * avg_degree)

For each of n gardens, we try up to 4 colors, checking up to 3 neighbors each time

✓ Linear Growth

Space Complexity

O(n + m)

Space for adjacency list where m is the number of paths

⚡ Linearithmic Space

38.4K Views

Medium Frequency

~15 min Avg. Time

1.5K 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

Naive Graph Coloring — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler