Projection Area of 3D Shapes

Projection Area of 3D Shapes - Problem

You are given an n x n grid where we place some 1 x 1 x 1 cubes that are axis-aligned with the x, y, and z axes.

Each value v = grid[i][j] represents a tower of v cubes placed on top of the cell (i, j).

We view the projection of these cubes onto the xy, yz, and zx planes. A projection is like a shadow, that maps our 3-dimensional figure to a 2-dimensional plane. We are viewing the "shadow" when looking at the cubes from the top, the front, and the side.

Return the total area of all three projections.

Input & Output

Example 1 — Basic 2x2 Grid

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

› Output: 14

💡 Note: XY projection (top view): 4 non-zero cells. YZ projection (front view): max(1,2) + max(3,1) = 2 + 3 = 5. ZX projection (side view): max(1,3) + max(2,1) = 3 + 2 = 5. Total = 4 + 5 + 5 = 14.

Example 2 — Single Row

$ Input: grid = [[2]]

› Output: 5

💡 Note: XY projection: 1 non-zero cell. YZ projection: max height in row = 2. ZX projection: max height in column = 2. Total = 1 + 2 + 2 = 5.

Example 3 — With Zero Heights

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

› Output: 8

💡 Note: XY projection: 2 non-zero cells. YZ projection: max(1,0) + max(0,2) = 1 + 2 = 3. ZX projection: max(1,0) + max(0,2) = 1 + 2 = 3. Total = 2 + 3 + 3 = 8.

Constraints

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

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12

The key insight is understanding that projections are shadows cast from different viewpoints. XY projection counts non-zero cells (top view), YZ projection sums maximum heights per row (front view), and ZX projection sums maximum heights per column (side view). Best approach uses a single pass optimization. Time: O(n²), Space: O(n)

Common Approaches

✓ Brute Force - Separate Projection Calculations

⏱️ Time: O(n²) Space: O(1)

Make three separate passes through the grid to calculate each projection area independently. For xy projection, count non-zero cells. For yz projection, find max height in each row. For zx projection, find max height in each column.

Single Pass Optimization

⏱️ Time: O(n²) Space: O(n)

Traverse the grid once and calculate all three projections simultaneously. Track row maximums and column maximums during the single traversal, while counting non-zero cells for the top projection.

Brute Force - Separate Projection Calculations — Algorithm Steps

Step 1: Calculate xy projection by counting non-zero grid cells
Step 2: Calculate yz projection by finding maximum height in each row
Step 3: Calculate zx projection by finding maximum height in each column
Step 4: Sum all three projection areas

Visualization

Tap to expand

Step-by-Step Walkthrough

XY Projection (Top View)

Count non-zero cells

YZ Projection (Front View)

Find max height per row

ZX Projection (Side View)

Find max height per column

Code -

solution.c — C

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

int solution(int** grid, int n) {
    // XY projection (top view) - 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 (front view) - max height in each row
    int yzArea = 0;
    for (int i = 0; i < n; i++) {
        int maxHeight = 0;
        for (int j = 0; j < n; j++) {
            if (grid[i][j] > maxHeight) {
                maxHeight = grid[i][j];
            }
        }
        yzArea += maxHeight;
    }
    
    // ZX projection (side view) - max height in each column
    int zxArea = 0;
    for (int j = 0; j < n; j++) {
        int maxHeight = 0;
        for (int i = 0; i < n; i++) {
            if (grid[i][j] > maxHeight) {
                maxHeight = grid[i][j];
            }
        }
        zxArea += maxHeight;
    }
    
    return xyArea + yzArea + zxArea;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    int** grid = malloc(50 * sizeof(int*));
    for (int i = 0; i < 50; i++) {
        grid[i] = malloc(50 * sizeof(int));
        memset(grid[i], 0, 50 * sizeof(int));
    }
    
    int n = 0;
    int row = 0, col = 0;
    char* ptr = input;
    int inNumber = 0;
    int currentNumber = 0;
    
    while (*ptr) {
        if (*ptr >= '0' && *ptr <= '9') {
            if (!inNumber) {
                inNumber = 1;
                currentNumber = 0;
            }
            currentNumber = currentNumber * 10 + (*ptr - '0');
        } else {
            if (inNumber) {
                grid[row][col] = currentNumber;
                col++;
                inNumber = 0;
            }
            if (*ptr == ']' && *(ptr+1) != ']') {
                if (col > 0) {
                    row++;
                    col = 0;
                }
            }
        }
        ptr++;
    }
    
    n = row + (col > 0 ? 1 : 0);
    
    printf("%d\n", solution(grid, n));
    
    for (int i = 0; i < 50; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Three separate passes through n×n grid

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

28.5K Views

Medium Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Separate Projection Calculations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler