三维形体的表面积(surface-area-of-3d-shapes)

题目

在 N * N 的网格上，我们放置一些 1 * 1 * 1 的立方体。
每个值 v = grid[i][j] 表示 v 个正方体叠放在对应单元格 (i, j) 上。
请你返回最终形体的表面积。

例 1：

输入：[[2]]
输出：10

示例 2：

输入：[[1,2],[3,4]]
输出：34

示例 3：

输入：[[1,0],[0,2]]
输出：16

示例 4：

输入：[[1,1,1],[1,0,1],[1,1,1]]
输出：32

示例 5：

输入：[[2,2,2],[2,1,2],[2,2,2]]
输出：46

提示：

1 <= N <= 50
0 <= grid[i][j] <= 50

题解

这道题目读起来就有一点萌，更不要说解题了。我们不凡看看英文版

On a N * N grid, we place some 1 * 1 * 1 cubes.

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

Return the total surface area of the resulting shapes.

通过英文版 ，我看可以看到原来，v是value的意思，

方法一：做加法的思路

我们可以将单元格 (i, j) 上堆叠的 v 个正方体看成一个高度为 v 的柱子，然后分别计算每个柱子的表面积。

首先，v > 0 的话，柱子顶部、底部的表面积都是 1。

然后是上、下、左、右四个侧面的表面积。以左侧的表面积为例：

如果柱子位于网格左边缘，左侧没有其他柱子，那么左侧表面积为 v；
如果柱子比左边的柱子矮，那么左侧露不出来，表面积为 0；
如果柱子比左边的柱子高，假设左边柱子高度为 v'，那么左边露出来的表面积为 v - v'。
我们可以把三种情况合并成一个表达式：j-1 >= 0 ? Math.max(grid[i][j] - grid[i][j-1], 0) : grid[i][j]。

其余的三个侧面以此类推。这样写出题解代码：

public int surfaceArea(int[][] grid) {
    int N = grid.length;
    int res = 0;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            // 上边露出的表面积
            res += i-1 >= 0 ? Math.max(grid[i][j] - grid[i-1][j], 0) : grid[i][j];
            // 下边露出的表面积
            res += i+1 < N ? Math.max(grid[i][j] - grid[i+1][j], 0) : grid[i][j];
            // 左边露出的表面积
            res += j-1 >= 0 ? Math.max(grid[i][j] - grid[i][j-1], 0) : grid[i][j];
            // 右边露出的表面积
            res += j+1 < N ? Math.max(grid[i][j] - grid[i][j+1], 0) : grid[i][j];
            // 顶部、底部的表面积
            res += 2 * (grid[i][j] > 0 ? 1 : 0);
        }
    }
    return res;
}

测试

    public static void main(String[] args) {
//    	[[1,2],[3,4]]  --->34
//    	[[1,0],[0,2]] ---->16
//    	[[1,1,1],[1,0,1],[1,1,1]] --->32
//    	[[2,2,2],[2,1,2],[2,2,2]] --->46
    	
//    	int[][] grid = {{1,2},{3,4}};
    	int[][] grid = {{2}};
    	Solution s = new Solution();
    	System.out.println(s.surfaceArea(grid));
	}

方法二：做减法的思路

我认为这个方法更加巧妙，我们先计算全部的表面积，然后再减去重叠的部分。

假设一共有 n 个立方体，每个立方体都有六个面，那么总的表面积应该是 6n。但是这些正方体堆叠在了一起，需要减掉一些因为堆叠而露不出来的表面积。每一对相邻的立方体接触在一起，都会让表面积减少 2。假设一共有 e 对相接触的立方体，即有 e 个接触面，表面积就会减少 2e。那么，最终的表面积就应该是 6n - 2e。

那么如何计算立方体的接触面呢？很简单，我们还是把每个单元格上堆叠的 v 个立方体看成一个柱子。立方体的接触面可以分为柱子内部和柱子之间的接触面：

v 个立方体的柱子内部，有 v - 1 个接触面
高度分别为 v、w 的两个立方体之间的接触面为 min(v, w)
我们可以按这个思路写出题解代码：

public int surfaceArea(int[][] grid) {
    int N = grid.length;
    int cubes = 0; // 记录立方体的数量
    int faces = 0; // 记录立方体接触面的数量
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            cubes += grid[i][j];
            if (grid[i][j] > 0) {
                // 叠起来的 v 个立方体有 v-1 个接触面
                faces += grid[i][j] - 1;
            }
            if (i > 0) {
                // 当前柱子与上边柱子的接触面数量
                faces += Math.min(grid[i-1][j], grid[i][j]);
            }
            if (j > 0) {
                // 当前柱子与左边柱子的接触面数量
                faces += Math.min(grid[i][j-1], grid[i][j]);
            }
        }
    }
    return 6 * cubes - 2 * faces;
}

官方题解-分步累加

class Solution {
    public int surfaceArea(int[][] grid) {
        int[] dr = new int[]{0, 1, 0, -1};
        int[] dc = new int[]{1, 0, -1, 0};

        int N = grid.length;
        int ans = 0;

        for (int r = 0; r < N; ++r)
            for (int c = 0; c < N; ++c)
                if (grid[r][c] > 0) {
                    ans += 2;
                    for (int k = 0; k < 4; ++k) {
                        int nr = r + dr[k];
                        int nc = c + dc[k];
                        int nv = 0;
                        if (0 <= nr && nr < N && 0 <= nc && nc < N)
                            nv = grid[nr][nc];

                        ans += Math.max(grid[r][c] - nv, 0);
                    }
                }

        return ans;
    }
}

注意，

        int[] dr = new int[]{0, 1, 0, -1};
        int[] dc = new int[]{1, 0, -1, 0};

这两个数据是用来定义上下左右的方向。

参考资料

3ms, 有图有真相, 一看就明白, Java
两种思路：做加法与做减法