java数据结构与算法刷题目录（剑指Offer、LeetCode、ACM）-----主目录-----持续更新(进不去说明我没写完)：https://blog.csdn.net/grd_java/article/details/123063846

回溯+深度优先遍历

解题思路：时间复杂度O($m\ast n+s\ast num$)，m*n是将整个board数组遍历了一遍，s是字符串word的长度，num是word这个字符串的第一个字符在board出现了几次。空间复杂度O($m\ast n\ast 2$)

1. 先创建一个hash表，key保存board中出现的字符，value保存对应字符的所有坐标，所需时间复杂度O($m\ast n$),空间复杂度O($m\ast n$)
2. 然后查看hash表，是否缺少word中的字符，因为缺少哪怕一个字符，都无法完成word的搜索，直接返回false即可。时间复杂度可以忽略不计
3. 从hash表获取word第一个字符的所有下标p，并遍历，所需时间复杂度为O(num),num为word中第一个字符在board的所有下标个数

每次遍历都需要visited数组标识我们本次路径上访问的位置，因为同一个位置不能访问多次，空间复杂度O($m\ast n$)

4. 以每个p为起点进行深度优先遍历（从上下左右四个方向依次比对），如果当前路径没有访问这个结点，并且成功和word中当前字符对应，就继续遍历。当整个word字符串都成功比对，就返回true。
5. 如果当前字符没有成功比对，就将当前位置的visited设置回false表示这个位置下次可以继续访问。然后回溯到上一步继续深度优先遍历

代码

class Solution {
    char[][] board;
    String word;
    int [][] directions = new int[][]{{-1,0},{0,-1},{1,0},{0,1}};//移动方向标量：上左下右
    public boolean exist(char[][] board, String word) {
        //将通用内容保存，不进行传参，否则降低代码可读性
        this.board = board;
        this.word = word;
        int row = board.length;
        int col = board[0].length;
        //将board中出现的每个字母的下标保存起来，key为字母，value为这个字母的下标
        Map<Character, List<int[]>> dict = new HashMap<>();
        for (int r = 0; r < row; r++) {
            for (int c = 0; c < col; c++) {
                List<int[]> val = dict.getOrDefault(board[r][c], new ArrayList<>());//如果字母第一次出现，就初始化
                val.add(new int[]{r, c});//将当前下标添加
                dict.put(board[r][c], val);
            }
        }
        //如果有要查找的单词中有字母不在字典，就返回false
        for (char ch : word.toCharArray()) {
            if (!dict.containsKey(ch)) return false;
        }
        //否则进行dfs查找，遍历word中第一个字母的所有下标
        for (int[] p : dict.get(word.charAt(0))) {//从第一个字母开始查找，其它的就不用找了，因为必须第一个字母开头
            boolean ret = dfs(p[0], p[1], new boolean[row][col], 0);//深度优先遍历查找
            if (ret) return true;//找到了就返回true
        }
        return false;//否则返回false
    }
    
    /**
     * 深度优先遍历
     * @param r 横坐标
     * @param c 纵坐标
     * @param path 当前查找访问路径，因为不可以重复
     * @param index //当前正在比对word中第几个字母
     * @return 是否完成word的搜索，是就返回true
     */
    private boolean dfs(int r, int c, boolean[][] path, int index) {
        int row = board.length;
        int col = board[0].length;
        if (index >= word.length()) return true;//所以字母比对完成就返回true
        //如果下标越界或者当前结点已经访问过，就返回false
        if (r < 0 || r >= row || c < 0 || c >= col || path[r][c]) return false;
        //开始回溯遍历
        char ch = word.charAt(index);//获取当前要比对的字母
        if (board[r][c] != ch) return false;//如果当前位置和字母对应不上，返回false
        //如果比对成功，设置当前位置已经访问过
        path[r][c] = true;
        //进行上下左右遍历，下面这个写法虽然稍微多遍历了几次（就很少的几次而已），但是代码可读性更高。
        //如果真的追求3ms的差距，可以选择用更下面注释的写法
        boolean ret = false;//默认比对失败
        for(int[] direction: directions){//获取上下左右移动标量
            int nextR = r+direction[0];//移动后横坐标
            int nextC = c+direction[1];//移动后纵坐标
            ret = dfs(nextR,nextC,path,index+1);//对其进行遍历
            if(ret) return true;//如果比对成功，返回true;
        }
        path[r][c] = false;//否则表示当前路径比对失败，将其设置为可访问状态
        return false;//比对失败，返回false。继续回溯
    //以下写法和上面写法的效果一样。虽然耗时更小（少一点点，3ms），但是代码非常不好看
    //    boolean ret = dfs(r + 1, c, path, index + 1);
    //    if (ret) return true;
       
    //    ret = dfs(r - 1, c, path, index + 1);
    //    if (ret) return true;
       
    //    ret = dfs(r, c + 1, path, index + 1);
    //    if (ret) return true;
       
    //    ret = dfs(r, c - 1, path, index + 1);
    //    if (ret) return true;
       
        // path[r][c] = false;
        // return false;
    }
}