Find All Groups of Farmland - Practice Coding Problems

Find All Groups of Farmland - Problem

Find All Rectangular Groups of Farmland

You're given an m x n binary matrix representing land where 0 represents forested areas and 1 represents farmland. The farmland is organized into rectangular groups - each group forms a perfect rectangle of connected farmland.

Key constraints:
• All farmland groups are rectangular in shape
• No two groups are adjacent (separated by forest or boundaries)
• Groups cannot be diagonal - only 4-directionally connected

Goal: Find the coordinates of the top-left and bottom-right corners of each rectangular farmland group. Return each group as [r1, c1, r2, c2] where (r1, c1) is top-left and (r2, c2) is bottom-right.

Example: If you find a farmland rectangle from (1,1) to (3,4), return [1, 1, 3, 4].

Input & Output

example_1.py — Basic rectangular groups

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

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

💡 Note: The first group is a 1x1 rectangle at position (0,0). The second group is a 2x2 rectangle from (1,1) to (2,2). Both are separate rectangular farmland areas.

example_2.py — Single large rectangle

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

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

💡 Note: The entire 2x2 matrix forms one rectangular group of farmland, with top-left at (0,0) and bottom-right at (1,1).

example_3.py — No farmland (edge case)

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

› Output: []

💡 Note: There is no farmland in the matrix (all cells are 0), so we return an empty array as there are no groups to identify.

Constraints

m == land.length
n == land[i].length
1 ≤ m, n ≤ 300
land[i][j] is either 0 or 1
All farmland groups are rectangular
No two groups are adjacent

Visualization

Tap to expand

Understanding the Visualization

Aerial Survey Begins

Start systematic scan from top-left, moving row by row

Spot Farm Corner

Identify top-left corner: farmland with no farms above or left

Trace Eastern Boundary

Follow the farm's eastern edge to find rightmost extent

Trace Southern Boundary

Follow the farm's southern edge to find bottommost extent

Mark Territory

Record farm boundaries and mark as surveyed

Continue Survey

Move to next unsurveyed area and repeat process

Key Takeaway

🎯 Key Insight: By identifying top-left corners (farmland cells with no farmland above or to the left), we can efficiently trace each rectangular farm's boundaries without redundant exploration, achieving optimal O(m*n) time complexity.

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 22

The optimal solution uses corner detection to identify top-left corners of rectangular farmland groups in a single pass. When a top-left corner is found (farmland with no farmland above or left), we trace the rectangle boundaries and mark the entire area as visited. This achieves O(m*n) time and O(1) space complexity by leveraging the rectangular constraint.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Corner Detection (Optimal)	O(m*n)	O(1)	Find top-left corners and immediately calculate bottom-right bounds in one pass
Brute Force (DFS/BFS for Each Cell)	O(m*n)	O(m*n)	Check every cell and run DFS/BFS to find complete rectangular groups

Single Pass Corner Detection (Optimal) — Algorithm Steps

Iterate through the matrix row by row, left to right
For each cell, check if it's a top-left corner (farmland with no farmland above or left)
When finding a top-left corner, trace right to find the rightmost column
Trace down to find the bottommost row
Mark all cells in the rectangle as visited (set to 0)
Record the rectangle bounds [top-left row, top-left col, bottom-right row, bottom-right col]

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan for Top-Left

Find farmland cell with no farmland above or left

Trace Right

Find the rightmost column of the rectangle

Trace Down

Find the bottommost row of the rectangle

Mark Rectangle

Mark entire rectangle as visited (set to 0)

Continue Scanning

Continue looking for next top-left corner

Code -

solution.c — C

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

int** findFarmland(int** land, int landSize, int* landColSize, int* returnSize, int** returnColumnSizes) {
    if (landSize == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    int m = landSize, n = landColSize[0];
    int** result = (int**)malloc(m * n * sizeof(int*));
    *returnColumnSizes = (int*)malloc(m * n * sizeof(int));
    int count = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            // Check if this is a top-left corner
            if (land[i][j] == 1 && 
                (i == 0 || land[i-1][j] == 0) && 
                (j == 0 || land[i][j-1] == 0)) {
                
                int r1 = i, c1 = j;
                
                // Find rightmost column
                int c2 = j;
                while (c2 < n && land[i][c2] == 1) {
                    c2++;
                }
                c2--;
                
                // Find bottommost row
                int r2 = i;
                while (r2 < m && land[r2][j] == 1) {
                    r2++;
                }
                r2--;
                
                // Mark all cells in rectangle as visited
                for (int r = r1; r <= r2; r++) {
                    for (int c = c1; c <= c2; c++) {
                        land[r][c] = 0;
                    }
                }
                
                int* bounds = (int*)malloc(4 * sizeof(int));
                bounds[0] = r1; bounds[1] = c1; bounds[2] = r2; bounds[3] = c2;
                result[count] = bounds;
                (*returnColumnSizes)[count] = 4;
                count++;
            }
        }
    }
    
    *returnSize = count;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Each cell is visited at most twice - once during scanning and once when marking as visited

✓ Linear Growth

Space Complexity

O(1)

No extra space if we modify input matrix, or O(m*n) if we use a visited array

✓ Linear Space

52.3K Views

Medium Frequency

~15 min Avg. Time

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

Single Pass Corner Detection (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler