[几何] LeetCode 892. 三维形体的表面积

[几何] LeetCode 892. 三维形体的表面积

在 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

dfs，因为看见这题第一个想到的是接雨水2，那个立体的图，虽然不会写那个，但是这个就想当然去搞dfs了

四种情况

自己的上下2面积

超界加上自己的侧面积

临接一个矩阵，加上0和面积差的最大值

走过了的格子，加上0和面积差的最大值

class Solution {
public:
    int res = 0, n, m;
    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
    vector<vector<bool>> flag;
    void dfs(int x, int y, vector<vector<int>>& grid){
        if(!flag[x][y] && grid[x][y]) res += 2;//自己的上下
        flag[x][y] = 1;
        for(int i = 0; i < 4; ++i){
            int nx = x + dx[i], ny = y + dy[i];
            if(nx<0||nx>=n||ny<0||ny>=m){//超界的
                res += grid[x][y];
                continue;
            }
            if(flag[nx][ny]){
                res += max(0, grid[x][y] - grid[nx][ny]);//走过的格子
                continue;
            }
            res += max(0, grid[x][y] - grid[nx][ny]);//下一步临界的格子
            dfs(nx, ny, grid);
        }
    }

    int surfaceArea(vector<vector<int>>& grid) {
        if(grid.empty()) return 0;
        n = grid.size(), m = grid[0].size();
        flag.resize(n,vector<bool>(m, 0));
        dfs(0, 0, grid);
        return res;
    }
};

emmm循环就得了

class Solution {
public:
    int surfaceArea(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size();
        int res = 0;
        for(int i = 0; i < n; ++i){
            for(int j = 0; j < m; ++j){
                //上
                res += i-1 >= 0 ? max(grid[i][j] - grid[i-1][j], 0) : grid[i][j];
                //下
                res += i+1 <  n ? max(grid[i][j] - grid[i+1][j], 0) : grid[i][j];
                //左
                res += j-1 >= 0 ? max(grid[i][j] - grid[i][j-1], 0) : grid[i][j];
                //右
                res += j+1 <  m ? max(grid[i][j] - grid[i][j+1], 0) : grid[i][j];
                //顶
                res += grid[i][j] == 0  ? 0 : 2;
            }
        }
        return res;
    }
};

看题解还有一种减法的写法，很巧妙，不用判断4个方向，只用判断上和左的重叠部分

class Solution {
public:
    int surfaceArea(vector<vector<int>>& grid) {
        int n = grid.size();
        int res = 0;
        for(int i = 0; i < n; ++i){
            for(int j = 0; j < n; ++j){
                if(grid[i][j] > 0){
                    res += grid[i][j] * 4 + 2;//总面积
                    if(i > 0) res -= min(grid[i][j], grid[i - 1][j]) * 2;//上
                    if(j > 0) res -= min(grid[i][j], grid[i][j - 1]) * 2;//左
                }
            }
        }
        return res;
    }
};