Surface Area of 3D Shapes

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

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

✓ Count All Faces Then Subtract Hidden

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

First, count 6 faces for each cube in every tower. Then, for each pair of adjacent cubes, subtract 2 faces (one from each cube) since they're glued together and hidden.

Direct Exposed Face Counting

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

Instead of counting all faces then subtracting, we directly count exposed faces. For each cube, we check its 6 directions (up, down, north, south, east, west) and count faces that are not blocked by adjacent cubes.

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>

static int grid[1000][1000];
static int gridColSize[1000];

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int solution(int gridSize) {
    if (gridSize == 0) return 0;
    
    int surfaceArea = 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 < gridSize; j++) {
            if (grid[i][j] > 0) {
                // Each cube tower of height h has:
                // - 6 * h total faces initially
                // - Minus 2 * (h-1) internal faces (between stacked cubes)
                int height = grid[i][j];
                int faces = 6 * height - 2 * (height - 1);
                surfaceArea += faces;
                
                // Subtract hidden faces with neighbors
                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 < gridSize && grid[ni][nj] > 0) {
                        // Hidden faces = min of the two heights
                        int hidden = grid[i][j] < grid[ni][nj] ? grid[i][j] : grid[ni][nj];
                        surfaceArea -= hidden;
                    }
                }
            }
        }
    }
    
    return surfaceArea;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse the grid
    int gridSize = 0;
    char* p = strchr(line, '[');
    if (p) p++; // Skip first '['
    
    char* rowStart = p;
    int inRow = 0;
    while (*p) {
        if (*p == '[' && !inRow) {
            inRow = 1;
            rowStart = p;
        } else if (*p == ']' && inRow) {
            char rowStr[1000];
            int len = p - rowStart + 1;
            strncpy(rowStr, rowStart, len);
            rowStr[len] = '\0';
            parseArray(rowStr, grid[gridSize], &gridColSize[gridSize]);
            gridSize++;
            inRow = 0;
        }
        p++;
    }
    
    printf("%d\n", solution(gridSize));
    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