LeetCode 回溯专题 6：二维平面上使用回溯法

初步体会使用一个数组来表示方向位移的技巧，体会使用递归在二维平面上搜索匹配的过程，有点暴力搜索的意思，只不过这个暴力搜索是有规律可循的。

在具体的编程上有一个小技巧。注意一个设置辅助数组的技巧。

例1：LeetCode 第 79 题 ：单词搜索

传送门：Word Search。

给定一个二维网格和一个单词，找出该单词是否存在于网格中。

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

示例:

board =
[
  ['A','B','C','E'],
  ['S','F','C','S'],
  ['A','D','E','E']
]

给定 word = "ABCCED", 返回 true.
给定 word = "SEE", 返回 true.
给定 word = "ABCB", 返回 false.

注意：使用回溯的方法进行搜索，几乎是模板代码，多写几遍就熟练了。要特别理解回溯的过程中，状态要重置这个操作。

Python 代码：

class Solution:
    #         (x-1,y)
    # (x,y-1) (x,y) (x,y+1)
    #         (x+1,y)

    directions = [(0, -1), (-1, 0), (0, 1), (1, 0)]

    def exist(self, board, word):
        """
        :type board: List[List[str]]
        :type word: str
        :rtype: bool
        """

        m = len(board)
        n = len(board[0])

        marked = [[False for _ in range(n)] for _ in range(m)]
        for i in range(m):
            for j in range(n):
                # 对每一个格子都从头开始搜索
                if self.__search_word(board, word, 0, i, j, marked, m, n):
                    return True
        return False

    def __search_word(self, board, word, index,
                      start_x, start_y, marked, m, n):
        # 先写递归终止条件
        if index == len(word) - 1:
            return board[start_x][start_y] == word[index]

        # 中间匹配了，再继续搜索
        if board[start_x][start_y] == word[index]:
            # 先占住这个位置，搜索不成功的话，要释放掉
            marked[start_x][start_y] = True
            for direction in self.directions:
                new_x = start_x + direction[0]
                new_y = start_y + direction[1]
                if 0 <= new_x < m and 0 <= new_y < n and \
                        not marked[new_x][new_y] and \
                        self.__search_word(board, word,
                                           index + 1,
                                           new_x, new_y,
                                           marked, m, n):
                    return True
            marked[start_x][start_y] = False
        return False

Java 代码：

class Solution {
    /**
     * 从"上"这个方向开始，顺时针旋转得到的 4 个方向，分别是，上，右，下，左
     * 4 个方向产生的位移（不要与 x 轴、y 轴坐标相混淆，这里自己画一张图就能明白）
     */
    int[][] d = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
    int m;// 表格有多少行
    int n;// 表格有多少列
    boolean[][] visited;


    /**
     * 指定的坐标是否在表格内
     *
     * @param x
     * @param y
     * @return
     */
    private boolean inArea(int x, int y) {
        boolean inArea = x >= 0 && x < m && y >= 0 && y < n;
        return inArea;
    }

    // 函数入口
    public boolean exist(char[][] board, String word) {
        m = board.length; // 这个 board 有几行
        assert (m > 0); // 在至少有一行的情况下，我们才能谈列
        n = board[0].length; // 这个 board 有多少列
        visited = new boolean[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                visited[i][j] = false;
            }
        }

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (searchWord(board, word, 0, i, j)) {
                    return true;
                }
            }
        }
        return false;
    }


    /**
     * 从 board[startX][startY]
     *
     * @param board  单词表面板
     * @param word   待查找的单词
     * @param index  当前遍历的 word 的起始单词
     * @param startX 起始点的横坐标
     * @param startY 起始点的纵坐标
     * @return
     */
    private boolean searchWord(char[][] board, String word, int index, int startX, int startY) {
        // 循环终止条件，判断到最后一位
        if (index == word.length() - 1) {
            // 如果这个最后一位也符合 word 最后一位的字母，那么就返回了
            return board[startX][startY] == word.charAt(index);
        }

        // 如果当前在 word 中间的字符匹配，那么首先要做上标记
        boolean found = board[startX][startY] == word.charAt(index);
        if (found) {
            visited[startX][startY] = true;
            for (int i = 0; i < 4; i++) {
                int newX = startX + d[i][0];
                int newY = startY + d[i][1];
                // 如果没有越界，并且没有访问过，并且下一个是匹配的时候，才返回 true
                boolean inArea = inArea(newX, newY);
                if(inArea){
                    boolean currVisited = !visited[newX][newY];
                    if(currVisited){
                        if(searchWord(board, word, index + 1, newX, newY)){
                            return true;
                        }
                    }
                }
            }
            visited[startX][startY] = false;
        }

        return false;
    }
}

下一节我们介绍有一类在二维平面相关的经典问题，使用 floodfill 使用的经典问题，使用深度优先遍历。

（本节完）