初步体会使用一个数组来表示方向位移的技巧，体会使用递归在二维平面上搜索匹配的过程，有点暴力搜索的意思，只不过这个暴力搜索是有规律可循的。
在具体的编程上有一个小技巧。注意一个设置辅助数组的技巧。
例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 使用的经典问题，使用深度优先遍历。
（本节完）
