回溯——65、66

65、矩阵中的路径

解释很好

• 首先，遍历整个矩阵，我们可以找到和字符串str首字符相同的单元格，作为查找的起点，然后遍历它的上下左右四个字符，如果有和str下一个字符相同的，就以该单元格作为下一个遍历起点，依次进行，如果没有找到就回退到上一个字符，重新查找其他方向。整个过程是一个非常典型的回溯思路。

• 由于回溯法天生的递归特性，路径可以看做一个栈，当在矩阵中定位了路径中前n个字符的位置后，在第n个字符的上下左右（没有遍历过的）格子找第n+1个字符，如果没有找到，只能回退到第n-1个字符，重新定位第n个字符。

• 由于路径不能重复进入矩阵的格子，所以还需要一个和矩阵大小相同的布尔矩阵来标识每个单元格是否被访问过，这也是回溯法的惯用方法。

class Solution {
    public boolean exist(char[][] board, String word) {//第一个函数写搜索范围，调用搜索函数
        char[] words = word.toCharArray();//矩阵区域
        for(int i = 0; i < board.length; i++) {
            for(int j = 0; j < board[0].length; j++) {
                if(dfs(board, words, i, j, 0)) return true;//深度遍历搜索
            }
        }
        return false;
    }
    boolean dfs(char[][] board, char[] word, int i, int j, int k) {//矩阵、字符、行列索引 i j 、当前目标字符在 word 中的索引 k
        if(i >= board.length || i < 0 || j >= board[0].length || j < 0 || board[i][j] != word[k]) return false;//(1) 行或列索引越界 或 (2) 当前矩阵元素与目标字符不同 
        if(k == word.length - 1) return true;//k = len(word) - 1 ，即字符串 word 已全部匹配。
        board[i][j] = '\0';//标记当前矩阵元素： 将 board[i][j] 修改为 空字符 '' ，代表此元素已访问过，防止之后搜索时重复访问。
        boolean res = dfs(board, word, i + 1, j, k + 1) || dfs(board, word, i - 1, j, k + 1) || 
                      dfs(board, word, i, j + 1, k + 1) || dfs(board, word, i , j - 1, k + 1);//上、下、左、右 四个方向开启下层递归,有一条满足即可
        board[i][j] = word[k];//还原当前矩阵元素： 将 board[i][j] 元素还原至初始值，即 word[k]
        return res;
    }
}

import java.util.*;
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param matrix string字符串 
     * @param rows int整型 
     * @param cols int整型 
     * @param str string字符串 
     * @return bool布尔型
     */
    public boolean hasPath (String matrix, int rows, int cols, String str) {
        // write code here
        boolean[] visited = new boolean[rows*cols];
        char[] maxtrixs = matrix.toCharArray();//矩阵
        char[] strs =str.toCharArray();//字符串
        //遍历寻找最开始的一个匹配
        for(int i = 0;i < rows;i++){
            for(int j = 0;j < cols; j++){
                if(judge(maxtrixs,strs,visited,rows,cols,i,j,0)) return true;
            }
        }
        return false;
    }
    //k代表当已经匹配到几个了
    public boolean judge(char[] matrixs,char[] strs,boolean[] visited,int rows,int cols,int i,int j,int k){
        int is_visited_pos = i * cols + j;//计算将要访问的字母的下标
        if(i<0||i>=rows||j<0||j>=cols||visited[is_visited_pos]==true||matrixs[is_visited_pos]!=strs[k]){
            return false;
        }
        //如果第k个满足上面的条件，并且k等于要匹配的长度
        if(k==strs.length-1) return true;
        //如果符合以上的条件即把当前位置标记为已经访问
        visited[is_visited_pos] = true;
        //上下左右搜寻
        if(judge(matrixs,strs,visited,rows,cols,i-1,j,k+1)||
           judge(matrixs,strs,visited,rows,cols,i+1,j,k+1)||
           judge(matrixs,strs,visited,rows,cols,i,j-1,k+1)||
           judge(matrixs,strs,visited,rows,cols,i,j+1,k+1)
          )return true;//通过is_visited_pos寻找到了
        //如果没有通过is_visited_pos寻找到，说明is_visited_pos不通，将其重新置为没有访问
        visited[is_visited_pos] = false;
        return false;
    }
}

66、机器人的运动范围

清晰题解

class Solution {
    public int movingCount(int m, int n, int k) {
        boolean[][] visited = new boolean[m][n];//回溯法中要定义布尔变量   表示节点的状态
        return dfs(0, 0, m, n, k, visited);//开始回溯
    }

    private int dfs(int i, int j, int m, int n, int k, boolean visited[][]) {
        if (i < 0 || i >= m || j < 0 || j >= n || (i/10 + i%10 + j/10 + j%10) > k || visited[i][j]) {//索引超出范围，位数和相加大于K，返回0
            return 0;
        }
        visited[i][j] = true;//表示当前已被访问
        return dfs(i + 1, j, m, n, k, visited) + dfs(i - 1, j, m, n, k, visited) + 
               dfs(i, j + 1, m, n, k, visited) + dfs(i, j - 1, m, n, k, visited) + 1;//1 + 右方搜索的可达解总数 + 下方搜索的可达解总数
    }
}