剑指 Offer 12. 矩阵中的路径

剑指 Offer 12. 矩阵中的路径

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串全部字符的路径。路径能够从矩阵中的任意一格开始，每一步能够在矩阵中向左、右、上、下移动一格。若是一条路径通过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。

[["a","b","c","e"],
["s","f","c","s"],
["a","d","e","e"]]

但矩阵中不包含字符串“abfb”的路径，由于字符串的第一个字符b占据了矩阵中的第一行第二个格子以后，路径不能再次进入这个格子。

示例 1：

输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true

示例 2：

输入：board = [["a","b"],["c","d"]], word = "abcd"
输出：false

思路

golang

这是矩阵中的搜索问题，能够采用 深度优先遍历DFS+剪枝函数的思想：在长度为i,宽度为j的board数组中查找一条路径使得长度为k的word字符串知足。

DFS 解析：

• 递归参数： 当前元素在矩阵 board 中的行列索引 i 和 j ，当前目标字符在 word 中的索引 k 。
• 终止条件：
• 返回 false ： (1) 行或列索引越界 或 (2) 当前矩阵元素与目标字符不一样 或 (3) 当前矩阵元素已访问过 （ (3) 可合并至 (2) ） 。
• 返回 true ： k = len(word) - 1 ，即字符串 word 已所有匹配。
• 递推工做：
  标记当前矩阵元素： 将 board(i)(j)修改成空字符 ，表明此元素已访问过，防止以后搜索时重复访问。 搜索下一单元格： 朝当前元素的 上、下、左、右 四个方向开启下层递归，使用 或 链接 （表明只需找到一条可行路径就直接返回，再也不作后续 DFS ），并记录结果至 res 。 还原当前矩阵元素： 将 board(i)(j)元素还原至初始值，即 word[k] 。
  返回值： 返回布尔量 res ，表明是否搜索到目标字符串。

时间复杂度 ：M,N 分别为矩阵行列大小， K为字符串 word长度。则时间复杂度为O(3^KMN) ： 最差状况下，须要遍历矩阵中长度为 K字符串的全部方案，时间复杂度为 O(3^K)，设字符串长度为 K，搜索中每一个字符有上、下、左、右四个方向能够选择，舍弃回头（上个字符）的方向，剩下3种选择，所以方案数的复杂度为 O(3^K) 。矩阵中共有 MN 个起点，时间复杂度为 O(MN) 。

空间复杂度：搜索过程当中的递归深度不超过 K，所以系统因函数调用累计使用的栈空间占用 O(K)

func exist(board [][]byte, word string) bool {
	rows, cols := len(board), len(board[0])
	for i := 0; i < rows; i++ {
		for j := 0; j < cols; j++ {
			if dfs(board, word, i, j, 0) {
				return true
			}
		}
	}
	return false
}

func dfs(board [][]byte, word string, i, j, k int) bool {
	rows, cols := len(board), len(board[0])
	//递归终止条件(返回false)：索引i,j超出边界;board[i][j]!=word[k];当前元素已经被访问过 剪枝函数
	if i >= rows || i < 0 || j >= cols || j < 0 || board[i][j] != word[k] {
		return false
	}
	//递归终止条件(返回true)：k = len(word)-1
	if k == len(word)-1 {
		return true
	}
	//填充已经被遍历过的元素，防止重复访问
	board[i][j] = ' '

	//上下左右 找到一条知足的路径便可
	res := dfs(board, word, i+1, j, k+1) || dfs(board, word, i, j+1, k+1) || dfs(board, word, i-1, j, k+1) || dfs(board, word, i, j-1, k+1)
	board[i][j] = word[k]
	return res
}

js

/**
 * @param {character[][]} board
 * @param {string} word
 * @return {boolean}
 */
var exist = function(board, word) {
    let rows = board.length,cols = board[0].length;
    
    var dfs = function (board,word,i,j,k) {
        //判断递归终止条件(返回false)：索引超出边界 || board[i][j] = word[k] || 当前元素已经访问过
        if (i>=rows || i <0 || j >=cols || j<0 || board[i][j]!=word[k]) return false;
        //递归终止条件(返回true) word中最后一个字符已经被查找到 k = word.length - 1
        if (k == word.length-1) return true;
        //标记已经访问
        board[i][j] = ' ';
        //上下左右 只要存在一条路径便可
        let res = dfs(board,word,i+1,j,k+1) || dfs(board,word,i,j+1,k+1) || dfs(board,word,i-1,j,k+1) || dfs(board,word,i,j-1,k+1)
        //恢复当前访问过的元素
        board[i][j] = word[k];
        return res;
    }

    //在board二维数组中查询长度为k的word的路径
    for (let i = 0; i < rows; i++) {
        for (let j = 0; j < cols; j++) {
            if(dfs(board,word,i,j,0)) return true;
        }
    }

    return false;
};