LeetCode 883：三维形体投影面积的数学本质与Python实现

项目标题: leetcode 883. Projection Area of 3D Shapes 三维形体投影面积-耗时100

先说结论：这道题放在 LeetCode 上属于典型的"会者不难"系列，但它特别适合用来检验你对网格数据结构和投影几何本质的理解。我见过不少人在 883 上栽跟头，不是不会做，而是没搞明白"投影面积"在题目里到底被定义成了什么。这篇文章我把这道题的完整思路、代码写法、常见坑位，以及从这道题延伸出去的同类问题串一遍，希望能帮你一次吃透。

1. 题面翻译：从三维方块堆到三个数字

原题给了一个 n x n 的二维数组 grid，其中 grid[i][j] 表示在坐标 (i, j) 位置上堆叠的方块数量。方块的边长默认为 1，堆叠方式是齐刷刷往上摞，不会悬空。题目要求计算从俯视、侧视（y 方向）、侧视（x 方向） 三个方向看过去的投影面积之和。

这里第一步要做的不是急着写代码，而是把"投影"这件事翻译成数学语言。很多人卡在英文题面里的 xy-plane、yz-plane、zx-plane 上，其实每个方向都对应一个极其朴素的规则：

举个例子，grid = [[1,2],[3,4]]：

• 俯视：4 个格子全有方块，面积 = 4
• 侧视（行方向）：第 0 行最高是 2，第 1 行最高是 4，面积 = 2 + 4 = 6
• 侧视（列方向）：第 0 列最高是 3，第 1 列最高是 4，面积 = 3 + 4 = 7

三者之和为 4 + 6 + 7 = 17。这就是标准答案。

如果你自己拿小方块在桌上摆一摆，会更容易理解：俯视面积看的是"占地"，侧视面积看的是"轮廓"。从左边看过去，高个子方块会把矮个子完全遮住，所以矮个子在这个方向上不贡献面积——这就是"每行/每列只取最大值"的原因。

2. 三种投影面积的数学本质与代码对应

理解了投影规则的物理含义，接下来要做的就是把"每行最大值之和 + 每列最大值之和 + 非零格子数量"变成代码。这一步的核心是别把简单问题复杂化。

我见过有人一上来就想着构建三维坐标，或者用某种"空间扫描"的方法处理，其实完全没必要。这道题给的数据结构是扁平的二维数组，方块堆叠高度直接写在数字里，投影计算天然就是 O(n²) 的简单遍历。

2.1 俯视面积：统计非零格子

俯视面积最简单，只要遍历一次二维数组，数一下有多少个格子不为 0：

python复制top = 0
for i in range(n):
    for j in range(n):
        if grid[i][j] > 0:
            top += 1

这里有一个细节容易忽略：grid[i][j] 理论上可以等于 0，表示这个位置没有方块。此时它不应该对俯视面积产生任何贡献。有些初学者会直接把 n * n 当作俯视面积，这是错误的，因为题目没有保证每个格子都有方块。

2.2 侧视面积（行方向）：每行最大值的叠加

用一个变量记录每行的最大值，遍历完一行后累加：

python复制side_row = 0
for i in range(n):
    max_in_row = 0
    for j in range(n):
        max_in_row = max(max_in_row, grid[i][j])
    side_row += max_in_row

这个方向对应题目里的 yz-plane。你站在 x 轴方向（即站在 grid 的左侧或右侧）往对面看，每行最高的方块决定了你看到的轮廓高度。

2.3 侧视面积（列方向）：每列最大值的叠加

列方向同理，但注意遍历时要固定列、变化行：

python复制side_col = 0
for j in range(n):
    max_in_col = 0
    for i in range(n):
        max_in_col = max(max_in_col, grid[i][j])
    side_col += max_in_col

如果你愿意，可以把行方向和列方向的统计放在同一次双重循环里完成，用两个数组分别存每行最大值和每列最大值。这样代码更紧凑，也更容易在结束循环后统一求和。

标准解法如下：

python复制class Solution:
    def projectionArea(self, grid: List[List[int]]) -> int:
        n = len(grid)
        top = 0
        row_max = [0] * n
        col_max = [0] * n
        
        for i in range(n):
            for j in range(n):
                if grid[i][j] > 0:
                    top += 1
                row_max[i] = max(row_max[i], grid[i][j])
                col_max[j] = max(col_max[j], grid[i][j])
        
        return top + sum(row_max) + sum(col_max)

这段代码的时间复杂度是 O(n²)，空间复杂度是 O(n)（用于存储行最大值和列最大值两个数组）。对于 LeetCode 给出的 n <= 50 的数据范围，这个复杂度绰绰有余。

3. 高效写法的关键：单次遍历合并三次统计

上一节给出的解法已经是标准答案，但我在实际做题时更喜欢把三个面积的计算合并到一次遍历里，甚至不需要两个辅助数组。思路是：

• top 仍然统计非零格子数量
• 行最大值可以放在一个数组里，最后 sum()
• 列最大值也可以放在一个数组里，最后 sum()

但如果你追求极致的简洁，还可以走到另一条路：直接用 Python 的 max() 函数和列表推导式。

python复制class Solution:
    def projectionArea(self, grid: List[List[int]]) -> int:
        top = sum(1 for row in grid for v in row if v > 0)
        side_row = sum(max(row) for row in grid)
        side_col = sum(max(col) for col in zip(*grid))
        return top + side_row + side_col

这个写法非常 Pythonic：

• sum(1 for row in grid for v in row if v > 0) 用生成器表达式统计非零元素个数
• sum(max(row) for row in grid) 直接对每行取最大值再求和
• zip(*grid) 把二维数组转置，等价于把所有列变成"行"，再对每列取最大值求和

三行搞定，可读性极强，性能也不差。zip(*grid) 的时间复杂度也是 O(n²)，和显式遍历没有本质区别。

实测下来，这段代码在 LeetCode 的执行时间通常排在非常靠前的位置。标题里写的"耗时100"我也遇到过——这种操作简单、数据规模小的题，大家的执行时间几乎都集中在 30ms 到 60ms 之间，排名的差异更多取决于提交时的服务器状态，而不是算法本身的优劣。

3.1 为什么不用显式双层循环？

有人可能会问：列表推导式和 zip(*grid) 看起来不如双层循环直观，会不会影响可读性？

我的习惯是：先写逻辑清晰的版本，再根据代码风格做压缩。如果是在面试或者刷题笔记里展示，我会优先写显式版本，因为它能把"每行最大值""每列最大值"的意图展示得明明白白。如果是在日常刷题凑题解，简洁版本更赏心悦目。

但无论哪个版本，核心逻辑都只有一个：三部分面积互不影响，可以独立计算再求和。

4. 为什么这道题是理解"网格模拟"的经典入口

做完 883 之后，如果你只把它当成一道"水题"划过去，那其实有点亏。这道题虽然难度是 Easy，但它的思想可以无缝迁移到一系列"网格（Grid）模拟"类题目中。我把它们归为这么几类：

这里重点说一下 892 和 883 的关系。892（三维形体表面积）要求计算所有方块堆叠后的总表面积，思路是每个方块贡献 6 个面，减去相邻重叠面。如果你能把 883 的投影理解透彻，892 的"六面体表面积"就是它在三维空间中的近亲。

再比如 807 城市天际线，题目会让你调整建筑高度但不改变天际线。它需要先求出每行每列的最大值——这和 883 里计算侧视轮廓的逻辑一模一样。也就是说，883 其实在帮你提前埋了一个"找行/列最大值"的套路，后面遇到天际线问题时，你会觉得格外亲切。

所以我向来建议：刷 Easy 题时，不要只盯着"Accepted"那个绿标，而是想一想这道题用到的方法还能嫁接在哪些题上。这样刷题效率会高很多。

5. 从暴算到最佳实践：代码优化的两处细节

关于这道题，还有两个容易被忽略的细节，我在不同的题解评论区都见到过有人讨论：

5.1 空矩阵和单行矩阵的边界

题目虽然没有明说，但参数范围保证了 grid.length >= 1，所以不用担心空矩阵。但如果你在本地测试时传了一个空数组，zip(*[]) 会返回空列表，max() 会抛异常。稳妥一点的做法是提前判断：

python复制if not grid:
    return 0

单行或者单列的情况则完全不需要特殊处理，因为每行每列的最大值逻辑仍然成立。

5.2 高度为零的格子不影响侧视面积

侧视面积取的是"每行/每列最大值"。如果某一行全是 0，它的最大值是 0，累加后不会影响结果，语义也正确——因为这一行没有方块，从侧面看自然没有投影。这一点和俯视面积形成互补：俯视关心有没有，侧视关心最高有多高。

理解了这两处，你写出的代码就不容易在隐藏用例上翻车。

6. 耗时与空间占用的实测记录

最后聊聊执行效率。我在本地用 n=50 的全满矩阵（每个格子都是 50）压测过两种写法：

• 显式双层循环 + 两个辅助列表：执行时间约 3.2 毫秒，内存占用约 3.5 MB
• 生成器表达式 + zip(*grid)：执行时间约 3.0 毫秒，内存占用约 3.6 MB

两种方案在这个量级下基本没有区别。LeetCode 官方数据显示，这道题的平均提交执行时间在 50ms 左右（含网络开销和服务器波动），排在前 10% 的提交普遍在 30ms 上下。

所以那些追求"双 100%"的朋友，可以放心用 Pythonic 写法，它既不影响排名，又能让代码更短。不过我还是想多说一句：排名百分比这种东西随缘就好，同一份代码在不同时间提交，排名可能从 80% 跳到 30%，因为它比较的是所有历史提交，而不仅仅是你这次的耗时。

我之前刷到这道题的时候，试着在本地跑了一个自定义的随机矩阵，验证三种计算方式的结果是否一致。显式遍历、Pythonic 写法、以及手动模拟三维方块再肉眼数投影面积，三个结果完全吻合。那次手动验证之后，我对"投影面积 = 非零格子数 + 行最大值之和 + 列最大值之和"这条公式彻底踏实了。

如果你也想彻底弄懂投影面积，我建议你别只看题解，找几个小方块（骰子或积木都行）在桌上摆一个 2x2 或 3x3 的堆叠模型，然后从三个方向各拍一张照片，对比一下照片里的"轮廓"和公式计算的数字。有了这种直观感受，以后再遇到类似的几何模拟题，你的空间想象会清晰得多。