Projection Area of 3D Shapes - Practice Coding Problems

Projection Area of 3D Shapes - Problem

Imagine you have a grid where you're stacking cubes to build 3D towers! 🏗️

Given an n × n grid, each cell grid[i][j] contains a value representing the height of a tower of unit cubes placed at position (i, j). Think of it like a 3D city skyline made of blocks!

Now, imagine shining light from three different directions to create shadows (projections) on three planes:

XY-plane (top view): Looking down from above
YZ-plane (side view): Looking from the right side
ZX-plane (front view): Looking from the front

Your task is to calculate the total area of all three shadow projections combined.

Key insight: A projection shows the "footprint" or "silhouette" of the 3D structure when viewed from that direction.

Input & Output

example_1.py — Basic 2x2 Grid

$ Input: grid = [[1,2],[3,4]]

› Output: 17

💡 Note: XY projection: 4 cells (all non-zero), YZ projection: max(1,2) + max(3,4) = 2+4 = 6, ZX projection: max(1,3) + max(2,4) = 3+4 = 7. Total: 4+6+7 = 17

example_2.py — Grid with Zeros

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

› Output: 8

💡 Note: XY projection: 2 cells (only positions with towers), YZ projection: max(2,0) + max(0,1) = 2+1 = 3, ZX projection: max(2,0) + max(0,1) = 2+1 = 3. Total: 2+3+3 = 8

example_3.py — Single Cell

$ Input: grid = [[1]]

› Output: 3

💡 Note: XY projection: 1 cell, YZ projection: max(1) = 1, ZX projection: max(1) = 1. Total: 1+1+1 = 3

Visualization

Tap to expand

Understanding the Visualization

Build 3D Structure

Visualize towers of cubes based on grid values

XY Projection (Top View)

Shadow from above shows occupied footprint

YZ Projection (Side View)

Shadow from side shows row silhouettes

ZX Projection (Front View)

Shadow from front shows column silhouettes

Key Takeaway

🎯 Key Insight: Each projection captures a different dimension of the 3D structure - footprint, side silhouette, and front silhouette. Calculate all three in one efficient pass!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Single pass through the n×n grid

⚠ Quadratic Growth

Space Complexity

O(n)

Arrays to store maximum values for each row and column

⚡ Linearithmic Space

Constraints

n == grid.length == grid[i].length
1 ≤ n ≤ 50
0 ≤ grid[i][j] ≤ 50

Asked in

G Google 15 a Amazon 8 ⊞ Microsoft 5 Apple 3

The optimal solution uses a single-pass approach to calculate all three projections simultaneously. Key insights: XY projection = count of non-zero cells, YZ projection = sum of row maximums, ZX projection = sum of column maximums. Time complexity: O(n²), Space complexity: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Three Separate Passes)	O(3n²) = O(n²)	O(1)	Calculate each projection separately with dedicated loops
One-Pass Optimal Solution	O(n²)	O(n)	Calculate all three projections in a single pass through the grid

Brute Force (Three Separate Passes) — Algorithm Steps

Pass 1: Iterate through all cells to count non-zero values (XY projection)
Pass 2: For each row, find the maximum value and add to YZ area
Pass 3: For each column, find the maximum value and add to ZX area
Return the sum of all three projection areas

Visualization

Tap to expand

Step-by-Step Walkthrough

XY Projection (Top View)

Count all non-zero cells - this gives us the footprint area

YZ Projection (Side View)

For each row, find the tallest tower and add its height

ZX Projection (Front View)

For each column, find the tallest tower and add its height

Code -

solution.c — C

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

int projectionArea(int** grid, int gridSize, int* gridColSize) {
    int n = gridSize;
    
    // XY projection: count non-zero cells
    int xyArea = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] > 0) xyArea++;
        }
    }
    
    // YZ projection: sum of row maximums
    int yzArea = 0;
    for (int i = 0; i < n; i++) {
        int rowMax = 0;
        for (int j = 0; j < n; j++) {
            if (grid[i][j] > rowMax) rowMax = grid[i][j];
        }
        yzArea += rowMax;
    }
    
    // ZX projection: sum of column maximums
    int zxArea = 0;
    for (int j = 0; j < n; j++) {
        int colMax = 0;
        for (int i = 0; i < n; i++) {
            if (grid[i][j] > colMax) colMax = grid[i][j];
        }
        zxArea += colMax;
    }
    
    return xyArea + yzArea + zxArea;
}

Time & Space Complexity

Time Complexity

⏱️

O(3n²) = O(n²)

Three separate passes through the n×n grid

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

Constraints

n == grid.length == grid[i].length
1 ≤ n ≤ 50
0 ≤ grid[i][j] ≤ 50

25.6K Views

Low Frequency

~12 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Three Separate Passes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler