Surface Area of 3D Shapes - Practice Coding Problems

Surface Area of 3D Shapes - Problem

You are given an n x n grid where you have placed some 1 x 1 x 1 cubes. Each value v = grid[i][j] represents a tower of v cubes placed on top of cell (i, j).

After placing these cubes, you have decided to glue any directly adjacent cubes to each other, forming several irregular 3D shapes.

Return the total surface area of the resulting shapes. Note: The bottom face of each shape counts toward its surface area.

Input & Output

Example 1 — Basic 2x2 Grid

$ Input: grid = [[2]]

› Output: 10

💡 Note: Single tower with height 2 has 2×4=8 side faces + 1 top + 1 bottom = 10 total faces

Example 2 — Adjacent Towers

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

› Output: 34

💡 Note: Four towers with glued faces: Tower 1: 6 faces, Tower 2: 10 faces, Tower 3: 14 faces, Tower 4: 22 faces, minus hidden connections = 34

Example 3 — Empty and Full

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

› Output: 16

💡 Note: Two separate towers (1 and 2 height) with no connections: 6 + 10 = 16 faces

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Input Grid

Each cell represents tower height

Build 3D Shape

Adjacent cubes glue together, hiding internal faces

Count Surface

Sum all exposed faces including bottom

Key Takeaway

🎯 Key Insight: Each cube has 6 faces, but adjacent cubes hide connecting faces - count only what's exposed

Asked in

F Facebook 35 a Amazon 28 G Google 22

The key insight is that each cube has 6 faces, but adjacent cubes hide faces between them. The optimal approach directly counts exposed faces: for each tower, add 2 faces (top/bottom) plus side faces that aren't blocked by neighbors. Time: O(n²), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Count All Faces Then Subtract Hidden	O(n²)	O(1)	Calculate total faces of all cubes, then subtract faces hidden by adjacent cubes
Direct Exposed Face Counting	O(n²)	O(1)	For each cube, count only the exposed faces by checking neighbors directly

Count All Faces Then Subtract Hidden — Algorithm Steps

Step 1: Count total faces = 6 × (sum of all cube heights)
Step 2: For each cell, check adjacent cells and subtract hidden faces
Step 3: Return total faces minus hidden faces

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Total Faces

Each cube has 6 faces

Find Hidden Faces

Adjacent cubes hide faces between them

Calculate Result

Total faces minus hidden faces

Code -

solution.c — C

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

int solution(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0) return 0;
    
    int totalCubes = 0;
    for (int i = 0; i < gridSize; i++) {
        for (int j = 0; j < gridColSize[i]; j++) {
            totalCubes += grid[i][j];
        }
    }
    int totalFaces = totalCubes * 6;
    
    int hiddenFaces = 0;
    int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    
    for (int i = 0; i < gridSize; i++) {
        for (int j = 0; j < gridColSize[i]; j++) {
            if (grid[i][j] > 0) {
                for (int d = 0; d < 4; d++) {
                    int ni = i + directions[d][0];
                    int nj = j + directions[d][1];
                    if (ni >= 0 && ni < gridSize && nj >= 0 && nj < gridColSize[ni]) {
                        int minHeight = grid[i][j] < grid[ni][nj] ? grid[i][j] : grid[ni][nj];
                        hiddenFaces += minHeight;
                    }
                }
            }
        }
    }
    
    return totalFaces - hiddenFaces / 2;
}

int main() {
    // Simple parsing for small test cases
    int grid[3][3] = {{1, 2}, {3, 4}};
    int* gridPtrs[2] = {grid[0], grid[1]};
    int colSizes[2] = {2, 2};
    
    printf("%d\n", solution(gridPtrs, 2, colSizes));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops to iterate through n×n grid

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables, no extra data structures

✓ Linear Space

34.0K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Count All Faces Then Subtract Hidden — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler