减少多余的计算-LeetCode79-单词搜索

题目

给定一个二维网格和一个单词，找出该单词是否存在于网格中。
单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
示例:
board =
[
  ['A','B','C','E'],
  ['S','F','C','S'],
  ['A','D','E','E']
]
给定 word = "ABCCED", 返回 true.
给定 word = "SEE", 返回 true.
给定 word = "ABCB", 返回 false.

思路

从word第一个字母开始，上下左右递归即可。

代码

class Solution {
    public static boolean res;
    public boolean exist(char[][] board, String word) {
        res=false;
        if(word.length()>board.length*board[0].length){
            return false;
        }
        int a=-1;
        int b=-1;
        for(int l=0;l<board.length*board[0].length;l++){
            int i=l/board[0].length;
            int j=l%board[0].length;
            if(board[i][j]==word.charAt(0)){  
                if(word.length()==1){
                    return true;
                }
                a=i;
                b=j;
                int[][] used=new int[board.length][board[0].length]; 
                digui(board[i][j],i,j,board,used,word,word.length());
                //已经得到true的结，剩下的计算不用再做。解决了超时的问题。
                if(res==true){
                    return res;
                }
           }
        }
        return res;
    }
    public void digui(char c,int i,int j,char[][] board,int[][] used,String word,int wordused){
        //已经得到true的结，剩下的计算不用再做。解决了超时的问题。
        if(res==true){
            return;
        }
        
        used[i][j]=1;
        wordused--;
        if(wordused==0){
            res=true;
            return;
        }
        
        char newc=word.charAt(word.length()-wordused);
        //left
        if(j>0){
            if(board[i][j-1]==newc&&used[i][j-1]==0){
                digui(newc,i,j-1,board,used,word,wordused);
                //由于递归参数中是int[][]类型，所以递归完成后要清理，目的是恢复递归之前的值。
                used[i][j-1]=0;
            }
        }
        //right
        if(j<board[0].length-1){
            if(board[i][j+1]==newc&&used[i][j+1]==0){
                digui(newc,i,j+1,board,used,word,wordused);
                //由于递归参数中是int[][]类型，所以递归完成后要清理，目的是恢复递归之前的值。
                used[i][j+1]=0;
            }
        }
        //up
        if(i>0){
            if(board[i-1][j]==newc&&used[i-1][j]==0){
                digui(newc,i-1,j,board,used,word,wordused);
                //由于递归参数中是int[][]类型，所以递归完成后要清理，目的是恢复递归之前的值。
                used[i-1][j]=0;
            }
        }
        //diow
        if(i<board.length-1){
            if(board[i+1][j]==newc&&used[i+1][j]==0){
                digui(newc,i+1,j,board,used,word,wordused);
                //由于递归参数中是int[][]类型，所以递归完成后要清理，目的是恢复递归之前的值。
                used[i+1][j]=0;
            }
        }
    }   

}

注意

1.由于递归参数中有int[][]类型，所以递归完成后要清理，目的是恢复递归之前的值。

2.二维数组的两层for循环可以用一层for循环替代：

for(int l=0;l<board.length*board[0].length;l++){
            int i=l/board[0].length;
            int j=l%board[0].length;
}

3.如果已经拿到所要的结果，剩下的一些计算可以省去，见代码中的注释部分。解决了超时的问题。