Hot 100 | 79. 单词搜索、200. 岛屿数量

LeetCode 79. 单词搜索

        给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

        单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

word = "ABCCED"、word = "SEE"、word = "ABCB"

• 思路：
  • 主函数用 i，j 遍历 board：将每一个 board[i][j] 作为 word[0] 去匹配
  • 一旦遇到word[0]（index 为0）👉调子函数，board[x][y] 置空，递归地到与之相邻的位置（上下左右）寻找 word[index + 1]
  • board[x][y] 置空：避免走回头路，上图中第三个例子，在已经匹配上“ABC”的情况下继续匹配‘B'，左边的’B'已经用过，如果匹配第一个‘B’时不做置空处理👉重复使用board[0][1]
• 代码：

class Solution {
public:
    // board[x][y]作为word[i]能不能找到word
    bool backtracking(vector<vector<char>>& board, int x, int y, const string& word, int i) {
        // 终止条件
        if (i >= word.size()) return true;
        if (x < 0 || x >= board.size() || y < 0 || y >= board[0].size() || board[x][y] != word[i]) return false;
        // board[x][y] == word[i]
        board[x][y] = ' '; // 防止匹配word(i, size)时，重复用board[x][y]
        // 继续到上下左右找 word[i + 1]
        bool res = backtracking(board, x - 1, y, word, i + 1) || backtracking(board, x + 1, y, word, i + 1) || backtracking(board, x, y - 1, word, i + 1) || backtracking(board, x, y + 1, word, i + 1);
        if (res) return true;
        // 恢复现场
        board[x][y] = word[i];
        return false;
    }
    bool exist(vector<vector<char>>& board, string word) {
        for (int i = 0; i < board.size(); ++i) {
            for (int j = 0; j < board[0].size(); ++j) {
                if (backtracking(board, i, j, word, 0)) return true;
            }
        }
        return false;
    }
};

LeetCode 200. 岛屿数量

        给你一个由 '1'（陆地）和 '0'（水）组成的二维网格 grid，请你计算网格中岛屿的数量。岛屿总是被水包围，并且每座岛屿只能由水平方向、竖直方向上相邻的陆地连接形成。

        此外，你可以假设该网格的四条边均被水包围。

• 思路：
  • 法一：dfs（递归）
    • 主函数用 i，j 遍历 grid：到每一个 grid[i][j] 找 ‘1’
    • 一旦遇到 ‘1’，岛数++👉调子函数，置为 ‘0’，递归地处理与之相邻的 ‘1’（上下左右）
  • 法二：bfs（迭代）
    • 用 i，j 遍历 grid：到每一个 grid[i][j] 找 ‘1’
    • 一旦遇到 ‘1’，岛数++👉{i, j} 置为 ‘0’并入队，循环处理队列直至为空：弹出队首元素，与之相邻的‘1’置为0并入队
  • 法三：并查集
• 代码：

// 法一：dfs
class Solution {
public:
    // 处理 grid[x][y] 及相邻位置的 '1'
    void dfs(vector<vector<char>>& grid, int x, int y) {
        // 终止条件：越界 or 不是陆地
        if (x < 0 || x >= grid.size() || y < 0 || y >= grid[0].size() || grid[x][y] != '1') return;
        grid[x][y] = '0';
        dfs(grid, x - 1, y); // 上
        dfs(grid, x + 1, y); // 下
        dfs(grid, x, y - 1); // 左
        dfs(grid, x, y + 1); // 右
    }
    int numIslands(vector<vector<char>>& grid) {
        int result = 0;
        for (int i = 0; i < grid.size(); ++i) {
            for (int j = 0; j < grid[0].size(); ++j) {
                if (grid[i][j] == '1') {
                    ++result;
                    dfs(grid, i, j);
                }
            }
        }
        return result;
    }
};

// 法二：bfs
class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        int result = 0;
        queue<pair<int, int>> que; // 待处理的'1'→'0'
        // 每遍历到一个'1'，置为'0'，并令其坐标入队列，处理队列直至为空：出队一个，令其上下左右的'1'→'0'，并入队
        for (int i = 0; i < grid.size(); ++i) {
            for (int j = 0; j < grid[0].size(); ++j) {
                if (grid[i][j] == '0') continue;
                ++result;
                grid[i][j] = '0';
                que.push({i, j}); // 坐标入队
                while (!que.empty()) {
                    int x = que.front().first;
                    int y = que.front().second;
                    que.pop();
                    if (x - 1 >= 0 && grid[x - 1][y] == '1') {
                        grid[x - 1][y] = '0';
                        que.push({x - 1, y});
                    }
                    if (x + 1 < grid.size() && grid[x + 1][y] == '1') {
                        grid[x + 1][y] = '0';
                        que.push({x + 1, y});
                    }
                    if (y - 1 >= 0 && grid[x][y - 1] == '1') {
                        grid[x][y - 1] = '0';
                        que.push({x, y - 1});
                    }
                    if (y + 1 < grid[0].size() && grid[x][y + 1] == '1') {
                        grid[x][y + 1] = '0';
                        que.push({x, y + 1});
                    }
                }
            }
        }
        return result;
    }
};

⭐注意grid中存放的是 字符0、字符1