Find All Groups of Farmland - Problem

You are given a 0-indexed m x n binary matrix land where a 0 represents a hectare of forested land and a 1 represents a hectare of farmland.

To keep the land organized, there are designated rectangular areas of hectares that consist entirely of farmland. These rectangular areas are called groups. No two groups are adjacent, meaning farmland in one group is not four-directionally adjacent to another farmland in a different group.

land can be represented by a coordinate system where the top left corner of land is (0, 0) and the bottom right corner of land is (m-1, n-1). Find the coordinates of the top left and bottom right corner of each group of farmland. A group of farmland with a top left corner at (r1, c1) and a bottom right corner at (r2, c2) is represented by the 4-length array [r1, c1, r2, c2].

Return a 2D array containing the 4-length arrays described above for each group of farmland in land. If there are no groups of farmland, return an empty array. You may return the answer in any order.

Input & Output

Example 1 — Two Separate Groups

$ Input: land = [[1,0,0],[0,1,1],[0,1,1]]

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

💡 Note: First group is single cell at (0,0). Second group forms 2×2 rectangle from (1,1) to (2,2).

Example 2 — Single Large Rectangle

$ Input: land = [[1,1],[1,1]]

› Output: [[0,0,1,1]]

💡 Note: Entire 2×2 matrix is one farmland group with corners at (0,0) and (1,1).

Example 3 — No Farmland

$ Input: land = [[0,0],[0,0]]

› Output: []

💡 Note: No farmland cells found, so return empty array.

Constraints

m == land.length
n == land[i].length
1 ≤ m, n ≤ 300
land[i][j] is 0 or 1
Groups of farmland are rectangular in shape

Visualization

Tap to expand

Asked in

A Amazon 25 G Google 20 M Microsoft 15 F Facebook 12

The key insight is that farmland groups are guaranteed to be perfect rectangles. Best approach uses direct rectangle detection by expanding right and down from each top-left corner. Time: O(m×n), Space: O(m×n)

Common Approaches

✓ Brute Force with DFS

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

Iterate through each cell in the matrix. When we find an unvisited farmland cell (1), start a DFS to explore all connected farmland cells in that group. During DFS, track the minimum and maximum row and column coordinates to determine the rectangle boundaries.

Single Pass Rectangle Detection

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

Since each farmland group is guaranteed to be a rectangle, when we find the top-left corner of a group, we can determine the bottom-right corner by expanding right and down until we hit the boundary. Then mark all cells in this rectangle as visited to avoid revisiting.

Brute Force with DFS — Algorithm Steps

Iterate through all cells in the matrix
For each unvisited farmland cell, start DFS
During DFS, mark cells as visited and track min/max coordinates
Add rectangle coordinates [r1, c1, r2, c2] to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Start

Locate first unvisited farmland cell (1)

DFS Explore

Recursively visit all connected farmland cells

Track Bounds

Record min/max coordinates to form rectangle

Code -

solution.c — C

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

static int land[300][300];
static bool visited[300][300];
static int result[1000][4];
static int resultSize = 0;

void findFarmland(int** matrix, int rows, int cols, int r, int c) {
    int minR = r, minC = c, maxR = r, maxC = c;
    
    // Find the bounds of this rectangular farmland
    // First find the bottom-right corner
    while (maxR + 1 < rows && matrix[maxR + 1][c] == 1) maxR++;
    while (maxC + 1 < cols && matrix[r][maxC + 1] == 1) maxC++;
    
    // Mark all cells in this rectangle as visited
    for (int i = minR; i <= maxR; i++) {
        for (int j = minC; j <= maxC; j++) {
            visited[i][j] = true;
        }
    }
    
    // Add to result
    result[resultSize][0] = minR;
    result[resultSize][1] = minC;
    result[resultSize][2] = maxR;
    result[resultSize][3] = maxC;
    resultSize++;
}

void solution(int** matrix, int rows, int cols) {
    resultSize = 0;
    
    // Initialize visited array
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            visited[i][j] = false;
        }
    }
    
    // Find all farmland groups
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (matrix[i][j] == 1 && !visited[i][j]) {
                findFarmland(matrix, rows, cols, i, j);
            }
        }
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse the 2D matrix
    int rows = 0, cols = 0;
    
    // Count rows by counting opening brackets
    char* temp = line;
    bool inRow = false;
    while (*temp) {
        if (*temp == '[' && inRow) {
            rows++;
        } else if (*temp == '[' && !inRow) {
            inRow = true;
        }
        temp++;
    }
    
    // Parse the matrix
    char* p = line;
    while (*p && *p != '[') p++; // Skip to first [
    if (*p == '[') p++; // Skip outer [
    
    int r = 0;
    while (*p && r < rows) {
        while (*p && *p != '[') p++; // Find row start
        if (!*p) break;
        p++; // Skip [
        
        int c = 0;
        while (*p && *p != ']') {
            if (*p >= '0' && *p <= '9') {
                land[r][c++] = *p - '0';
                if (r == 0) cols = c; // Set cols from first row
            }
            p++;
        }
        if (*p == ']') p++; // Skip ]
        r++;
    }
    
    // Create matrix of pointers for the solution function
    int* matrix[300];
    for (int i = 0; i < rows; i++) {
        matrix[i] = land[i];
    }
    
    solution(matrix, rows, cols);
    
    // Output result
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        if (i > 0) printf(",");
        printf("[%d,%d,%d,%d]", result[i][0], result[i][1], result[i][2], result[i][3]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Each cell is visited at most twice: once during iteration and once during DFS

✓ Linear Growth

Space Complexity

O(m×n)

Visited array of same size as input matrix plus recursion stack depth

⚡ Linearithmic Space

32.5K Views

Medium Frequency

~25 min Avg. Time

892 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

Find All Groups of Farmland - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler