leetcode--Word Search

Given a 2D board and a word, find if the word exists in the grid.

The word can be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once.

For example,

Given board =

[
["ABCE"],
["SFCS"],
["ADEE"]
]

word = 

"ABCCED"

, -> returns 

true

,
word = 

"SEE"

, -> returns 

true

,

word = 

"ABCB"

, -> returns 

false

.

题意：给定一个二维数组，数组中存储着英文字符，判断某个英文序列，能否在数组中按照某个顺序找到。

每个字符只能被使用一次，每次只能向相邻的字符移动。

分类：数组，回溯

解法1：回溯，没有什么好说的，关键是边界判断。

[java] view
plain copy

public class Solution {  

    public boolean exist(char[][] board, String word) {  

        int rows = board.length;  

        int cols = board[0].length;  

        boolean[][] visited = new boolean[rows][cols];        

        for (int i=0;i<board.length;i++) {    

            for (int j=0;j<board[i].length;j++) {    

                if(board[i][j]==word.charAt(0)) {    

                    visited[i][j] = true;    

                    if(word.length()==1 || search(board,i,j,word.substring(1),visited)) {    

                        return true;    

                    }    

                    visited[i][j] = false;    

                }    

            }    

        }    

        return false;    

    }  

              

    private boolean search(char[][] board, int i, int j, String word,  

            boolean[][] visited) {  

        if(word.length()==0) return true;    

        //四个走向    

        int[][] direction = { {-1,0},{1,0},{0,-1},{0,1}};    

        for(int k=0;k<direction.length;k++){  

            int x = i+direction[k][0];  

            int y = j+direction[k][1];  

            if(x>=0&&x<board.length  

                &&y>=0&&y<board[0].length  

                &&!visited[x][y]  

                &&word.charAt(0)==board[x][y]){  

                visited[x][y] = true;                 

                if (word.length()==1 || search(board, x, y, word.substring(1), visited)) {    

                    return true;    

                }    

                visited[x][y] = false;  

            }  

        }  

        return false;  

    }  

}  

[java] view
plain copy

public class Solution {  

    public boolean exist(char[][] board, String word) {  

        int rows = board.length;  

        int cols = board[0].length;  

        boolean flag[][] = new boolean[rows][cols];  

        for(int i=0;i<rows;i++){  

            for(int j=0;j<cols;j++){  

                if(board[i][j]==word.charAt(0)){  

                    flag[i][j] = true;  

                    if(search(i,j,word.substring(1),rows,cols,flag,board)) return true;  

                    flag[i][j] = false;  

                }  

            }  

        }  

        return false;  

    }  

      

    public boolean search(int row,int col,String str,int rows,int cols,boolean[][] flag,char[][] board){  

        if(str.length()==0) return true;  

        int[] dirX = new int[]{1,-1,0,0};  

        int[] dirY = new int[]{0,0,1,-1};  

        for(int i=0;i<dirX.length;i++){  

            int x = row+dirX[i];  

            int y = col+dirY[i];  

            if(x>=0&&x<rows&&y>=0&&y<cols&&!flag[x][y]&&board[x][y]==str.charAt(0)){  

                flag[x][y] = true;  

                if(search(x,y,str.substring(1),rows,cols,flag,board)) return true;  

                flag[x][y] = false;  

            }  

        }  

        return false;  

    }  

}  

原文链接http://blog.csdn.net/crazy__chen/article/details/46425207