leetcode79——单词搜索

题意：

个人题解：

class Solution {
    boolean flag=false;
    
    public boolean exist(char[][] board, String word) {
        //单元格就是单元格
        char[] wc=word.toCharArray();
        int start=0;
        int i=0;
        int j=0;
        boolean[][] b=new boolean[board.length][board[0].length];
        dfs(board,wc,start,i,j,b);
        //return start==word.length()? true:false;
        return flag;
    }
    public void dfs(char[][] board,char[] wc,int start,int i,int j,boolean[][] b){// 行 列
        if(start==wc.length){
            flag=true;
            return;
        }
        //先找到首字母
        //走完之后不能回头
        //如何进入第二个点
        if(start==0){
            for(int m=i;m<board.length;m++){
                for(int n=j;n<board[0].length;n++){
                    if(board[m][n]==wc[start]){
                        b[m][n]=true;
                        dfs(board,wc,start+1,m,n,b);
                        
                    }
                    b=new boolean[board.length][board[0].length];
                    start=0;
                }
            }
        }else{
            if((i+1)<board.length && board[i+1][j]==wc[start] && b[i+1][j]!=true){
                b[i+1][j]=true;
                dfs(board,wc,start+1,i+1,j,b);
            }
            if((i-1)>=0 && board[i-1][j]==wc[start] && b[i-1][j]!=true){
                b[i-1][j]=true;
                dfs(board,wc,start+1,i-1,j,b);
            }

            if((j+1)<board[0].length && board[i][j+1]==wc[start]&& b[i][j+1]!=true){
                b[i][j+1]=true;
                dfs(board,wc,start+1,i,j+1,b);
            }
            if((j-1)>=0 && board[i][j-1]==wc[start] && b[i][j-1]!=true){
                b[i][j-1]=true;
                dfs(board,wc,start+1,i,j-1,b);
            }
        }
    }
}

但是不能全部通过

究其原因是，没有对不合理的回溯进行撤回处理

因在回溯主体后面加上撤回的操作

在这里是对标记点进行还原

b[i][j-1]=false;

个人正解：

class Solution {
    boolean flag=false;
    
    public boolean exist(char[][] board, String word) {
        //单元格就是单元格
        char[] wc=word.toCharArray();
        int start=0;
        int i=0;
        int j=0;
        boolean[][] b=new boolean[board.length][board[0].length];
        dfs(board,wc,start,i,j,b);
        //return start==word.length()? true:false;
        return flag;
    }
    public void dfs(char[][] board,char[] wc,int start,int i,int j,boolean[][] b){// 行 列
        if(start==wc.length){
            flag=true;
            return;
        }
        //先找到首字母
        //走完之后不能回头
        //如何进入第二个点
        if(start==0){
            for(int m=i;m<board.length;m++){
                for(int n=j;n<board[0].length;n++){
                    if(board[m][n]==wc[start]){
                        b[m][n]=true;
                        dfs(board,wc,start+1,m,n,b);
                        
                    }
                    b=new boolean[board.length][board[0].length];
                    start=0;
                }
            }
        }else{
            if((i+1)<board.length && board[i+1][j]==wc[start] && b[i+1][j]!=true){
                b[i+1][j]=true;
                dfs(board,wc,start+1,i+1,j,b);
                b[i+1][j]=false;

            }
            if((i-1)>=0 && board[i-1][j]==wc[start] && b[i-1][j]!=true){
                b[i-1][j]=true;
                dfs(board,wc,start+1,i-1,j,b);
                b[i-1][j]=false;
            }

            if((j+1)<board[0].length && board[i][j+1]==wc[start]&& b[i][j+1]!=true){
                b[i][j+1]=true;
                dfs(board,wc,start+1,i,j+1,b);
                b[i][j+1]=false;
            }
            if((j-1)>=0 && board[i][j-1]==wc[start] && b[i][j-1]!=true){
                b[i][j-1]=true;
                dfs(board,wc,start+1,i,j-1,b);
                b[i][j-1]=false;
            }
        }
    }
}

 官方正解：

算了 看样子得看评论区大佬：