思路

1. 初始化：

   • 定义矩阵的大小 m 和 n。
   • 使用两个布尔矩阵 pac 和 atl，分别表示从太平洋和大西洋可以到达的格子。

2. 深度优先搜索 (DFS)：

   • 从太平洋边界（第一行和第一列）和大西洋边界（最后一行和最后一列）开始 DFS，标记每个可以到达的格子。
   • dfs 函数会向四个方向探索，只在相邻格子的高度不低于当前格子的情况下继续探索。

3. 结果合并：

   • 遍历整个矩阵，收集同时在 pac 和 atl 中为 true 的格子，即能同时流向太平洋和大西洋的格子。

代码

class Solution {
public:
    int m, n;
    int dx[4] = {0, 0, -1, 1};
    int dy[4] = {-1, 1, 0, 0};

    vector<vector<int>> pacificAtlantic(vector<vector<int>>& heights) {
        m = heights.size();
        n = heights[0].size();
        vector<vector<bool>> pac(m, vector<bool>(n));
        vector<vector<bool>> atl(m, vector<bool>(n)); // 分别用于表示大西洋与太平洋的流向情况

        // 从外向内：
        // 太平洋 - 第一行与第一列的元素向内dfs
        for(int j = 0; j < n; ++j) dfs(heights, 0, j, pac); // 第一行
        for(int i = 0; i < m; ++i) dfs(heights, i, 0, pac); // 第一列

        // 大西洋 - 最后一行与最后一列
        for(int j = 0; j < n; ++j) dfs(heights, m - 1, j, atl); // 最后一行
        for(int i = 0; i < m; ++i) dfs(heights, i, n - 1, atl); // 最后一列

        vector<vector<int>> ret;
        for(int i = 0; i < m; ++i) // 遍历数组，找对于某位置，表示两大洋的数组均为true的
            for(int j = 0; j < n; ++j)
            {
                if(atl[i][j] && pac[i][j])
                    ret.push_back({i, j});
            }

        return ret;
    }

    void dfs(vector<vector<int>>& heights, int x, int y, vector<vector<bool>>& visited)
    {
        visited[x][y] = true;
        for(int k = 0; k < 4; ++k)
        {
            int _x = x + dx[k], _y = y + dy[k];
            if(_x >= 0 && _y >= 0 && _x < m && _y < n && !visited[_x][_y] && heights[_x][_y] >= heights[x][y])
            {
                dfs(heights, _x, _y, visited);
            }
        }
    }
};

思路

1. 初始化：

   • m 和 n 分别表示棋盘的行数和列数。
   • dx 和 dy 数组用于表示八个方向的偏移量，以便遍历当前位置周围的方块。具体方向是：左、右、上、下、右下、右上、左下、左上。

2. 更新棋盘 (updateBoard 函数)：

   • 获取点击位置 i 和 j。
   • 如果点击的位置是地雷（'M'），则将其标记为 'X'，并返回更新后的棋盘。
   • 如果点击的位置不是地雷，调用 dfs 函数来递归揭示相关区域。

3. 递归揭示 (dfs 函数)：

   • 统计当前位置周围8个方向的地雷数量 count。
   • 如果周围有地雷 (count > 0)，将当前位置标记为对应的数字（地雷的数量），并返回。
   • 如果周围没有地雷 (count == 0)，将当前位置标记为 'B'，并继续递归处理周围未揭示的方块（即 'E'）。

代码

class Solution {
public:
    int m, n;
    // 左上 上 右上 左 右 左下 下 右下
    // int dirs[8][2] = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}};
    int dx[8] = {0, 0, -1, 1, 1, 1, -1, -1};
    int dy[8] = {-1, 1, 0, 0, 1, -1, 1, -1};

    vector<vector<char>> updateBoard(vector<vector<char>>& board, vector<int>& click) {
        int i = click[0], j = click[1];
        m = board.size(), n = board[0].size();

        if(board[i][j] == 'M')
        {
            board[i][j] = 'X';
            return board;
        }

        dfs(board, i, j);

        return board;
    }

    void dfs(vector<vector<char>>& board, int i, int j)
    {
        int count = 0;
        // 统计当前位置周围的雷数
        for(int k = 0; k < 8; ++k)
        {
            int x = i + dx[k], y = j + dy[k];
            if(x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'M')
            {
                ++count;
            }
        }

        if(count) // 附近有雷
        {
            board[i][j] = count + '0';
            return;
        }   
        else    // 附近无雷
        {
            board[i][j] = 'B';
            for(int k = 0; k < 8; ++k) // 找周围未挖出方块，继续递归
            {
                int x = i + dx[k], y = j + dy[k];
                if(x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'E')
                {
                    dfs(board, x, y);
                }
            }
        }   
    }
};

思路

1. 初始化：

   • visited 是一个布尔矩阵，用于标记每个格子是否已经访问过。
   • dx 和 dy 数组分别表示在网格中向右和向下移动的偏移量。

2. wardrobeFinishing 函数：

   • 这个函数初始化 visited 矩阵，并设置 _cnt、_m 和 _n，然后从 (0, 0) 位置开始调用 dfs 函数。

3. dfs 函数：

   • 递归遍历满足条件的格子。
   • 首先，访问当前位置 (i, j)，并将 ret 计数器加 1。
   • 对于当前位置 (i, j)，尝试向右 (i, j+1) 和向下 (i+1, j) 移动，检查这些新位置是否在网格内、是否未被访问，以及它们的行索引和列索引的数位和是否小于等于 cnt。
   • 如果满足这些条件，递归调用 dfs 函数继续探索。

4. digit 函数：

   • 计算一个数字的数位和。例如，对于数字 23，它的数位和是 2 + 3 = 5。

代码

class Solution {
public:
    // cnt = 2 即表格 行与列元素 数位之和 <= cnt 的个数
    // \ 0 1 2  (m = n = 3)
    // 0 0 1 2
    // 1 1 2 X
    // 2 2 X X

    vector<vector<bool>> visited;
    int dx[2] = {1, 0};
    int dy[2] = {0, 1};
    int ret = 0, _cnt, _m, _n;

    int wardrobeFinishing(int m, int n, int cnt) {
        visited.resize(m, vector<bool>(n));
        _cnt = cnt, _m = m, _n = n;

        dfs(0, 0);
        return ret;
    }

    void dfs(int i, int j)
    {
        ++ret;
        visited[i][j] = true;

        for(int k = 0; k < 2; ++k)
        {
            // 统计 满足条件的格子
            int x = dx[k] + i, y = dy[k] + j;
            if(x >= 0 && x < _m && y >= 0 && y < _n && digit(x) + digit(y) <= _cnt && !visited[x][y])
                dfs(x, y);
        }
    }
    
    // 求数位之和
    int digit(int num)
    {
        int tmp = 0;
        while(num)
        {
            tmp += num % 10;
            num /= 10;
        }
        return tmp;
    }
};