Count Fertile Pyramids in a Land - Practice Coding Problems

Count Fertile Pyramids in a Land - Problem

A farmer has a rectangular grid of land with m rows and n columns where each cell can be either fertile (represented by 1) or barren (represented by 0). Your task is to count all possible pyramidal and inverse pyramidal plots that can be formed using only fertile cells.

A pyramidal plot has its apex at the top and expands downward in a diamond-like shape. For a pyramid with apex at position (r, c) and height h, it includes cells (i, j) where r ≤ i ≤ r + h - 1 and c - (i - r) ≤ j ≤ c + (i - r).

An inverse pyramidal plot has its apex at the bottom and expands upward. For an inverse pyramid with apex at (r, c) and height h, it includes cells (i, j) where r - h + 1 ≤ i ≤ r and c - (r - i) ≤ j ≤ c + (r - i).

Note: All pyramids must have height ≥ 2 (at least 4 cells total) and consist entirely of fertile land.

Input & Output

example_1.py — Basic Grid

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

› Output: 2

💡 Note: The grid has 2 pyramids: a regular pyramid with apex at (0,1) and height 2, and an inverse pyramid with apex at (1,1) and height 2.

example_2.py — All Ones

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

› Output: 4

💡 Note: There are 2 regular pyramids (apex at (0,1) with heights 2 and 3) and 2 inverse pyramids (apex at (2,1) with heights 2 and 3).

example_3.py — No Pyramids

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

› Output: 0

💡 Note: No valid pyramids can be formed as there are insufficient connected fertile cells in pyramid shapes.

Visualization

Tap to expand

Understanding the Visualization

Survey Land

Identify all fertile cells that can support construction

Build Foundation

Mark each fertile cell as capable of height-1 pyramid

Extend Upward

For each row, calculate maximum pyramid height based on support from above

Count Structures

Sum all pyramids with height ≥ 2 for final count

Key Takeaway

🎯 Key Insight: Dynamic programming eliminates redundant calculations by building pyramid heights incrementally, recognizing that larger pyramids contain smaller ones as substructures.

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each of mn cells, we check up to min(m,n) heights, and each height check takes O(h) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 1000
1 ≤ m × n ≤ 10⁵
grid[i][j] is either 0 or 1

Asked in

G Google 15 f Meta 8 a Amazon 6 ⊞ Microsoft 4

The optimal solution uses dynamic programming to count pyramids efficiently. We create two DP arrays: one for regular pyramids (processed top-to-bottom) and one for inverse pyramids (processed bottom-to-top). For each cell, the maximum pyramid height is determined by taking the minimum of the three cells in the previous layer plus one. The total count is the sum of all pyramid heights ≥ 2, achieving O(mn) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Positions)	O(m²n²)	O(1)	Check every cell as potential apex and try all possible pyramid heights
Dynamic Programming (Optimal)	O(mn)	O(mn)	Build pyramid heights incrementally using DP to avoid redundant calculations

Brute Force (Check All Positions) — Algorithm Steps

Iterate through each cell (r, c) as potential apex
For each apex, try heights from 2 to maximum possible
For each height, check if all cells in pyramid are fertile
Count valid pyramids and inverse pyramids separately
Return total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Apex

Choose a cell as potential pyramid apex

Try Heights

Test increasing heights from 2 upwards

Validate Shape

Check if all cells in pyramid are fertile

Code -

solution.c — C

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

bool isValidPyramid(int** grid, int m, int n, int r, int c, int h, bool inverse) {
    if (inverse) {
        if (r - h + 1 < 0) return false;
        for (int i = r - h + 1; i <= r; i++) {
            int width = r - i;
            if (c - width < 0 || c + width >= n) return false;
            for (int j = c - width; j <= c + width; j++) {
                if (grid[i][j] == 0) return false;
            }
        }
    } else {
        if (r + h - 1 >= m) return false;
        for (int i = r; i < r + h; i++) {
            int width = i - r;
            if (c - width < 0 || c + width >= n) return false;
            for (int j = c - width; j <= c + width; j++) {
                if (grid[i][j] == 0) return false;
            }
        }
    }
    return true;
}

int countPyramids(int** grid, int gridSize, int* gridColSize) {
    int m = gridSize, n = gridColSize[0];
    int count = 0;
    
    for (int r = 0; r < m; r++) {
        for (int c = 0; c < n; c++) {
            if (grid[r][c] == 1) {
                int h = 2;
                while (isValidPyramid(grid, m, n, r, c, h, false)) {
                    count++;
                    h++;
                }
                
                h = 2;
                while (isValidPyramid(grid, m, n, r, c, h, true)) {
                    count++;
                    h++;
                }
            }
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each of mn cells, we check up to min(m,n) heights, and each height check takes O(h) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 1000
1 ≤ m × n ≤ 10⁵
grid[i][j] is either 0 or 1

28.5K Views

Medium Frequency

~25 min Avg. Time

847 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Positions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler