lintcode---单词搜索

题目描述：
给出一个二维的字母板和一个单词，寻找字母板网格中是否存在这个单词。
单词可以由按顺序的相邻单元的字母组成，其中相邻单元指的是水平或者垂直方向相邻。每个单元中的字母最多只能使用一次。

样例：
给出board =

[

  "ABCE",

  "SFCS",

  "ADEE"

]

word = “ABCCED”， ->返回 true,

word = “SEE”，-> 返回 true,

word = “ABCB”， -> 返回 false.

思路分析：我们的思路很简单就是利用回溯法进行搜索，然后利用一个p二维数组，来存储是否对这个位置的字符进行过访问，0表示没有，1表示访问过，我们遍历找到word第一个出现的位置，然后葱这个位置开始进行递归，每次我们需要判断该位置的上下左右是否出现了下一个字符，如果是就继续执行，反之就回溯岛上一个位置的下一个。

详细代码：

class Solution {
public:
    /*
     * @param board: A list of lists of character
     * @param word: A string
     * @return: A boolean
     */
    int flag=0; //是否找到这个单词的标志
    bool exist(vector<vector<char>> &board, string &word) {
        // write your code here
        vector<vector<int>> map;

        if(board.empty()||board[0].empty())
        {
            return false;
        }
        int m=board.size();
        int n=board[0].size();
        int **p=new int*[m];//存储该位置是否被使用过
        for(int i=0;i<m;i++)
        {
            p[i]=new int[n];
        }
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++){
                p[i][j]=0;
            }
        }
        if(word.length()>m*n){
            return false;
        }
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(board[i][j]==word[0]){
                    if(word.length()==1){
                        return true;
                    }
                    p[i][j]=1;
                    dfs(board,word,p,1,i,j);
                    if(flag==1){
                        return true;
                    }
                }
            }
        }
        return false;
    }
    void dfs(vector<vector<char>> &board,string &word,int **p,int index,int i,int j)
    {
        int m=board.size();
        int n=board[0].size();

        if(0<=i-1&&flag==0){
            if(board[i-1][j]==word[index]&&p[i-1][j]==0){
                p[i-1][j]=1;
                if(index==word.length()-1){
                    flag=1;
                    return ;
                }
                dfs(board,word,p,index+1,i-1,j);
                p[i-1][j]=0;
            }
        }
        if(0<=j-1&&flag==0){
            if(board[i][j-1]==word[index]&&p[i][j-1]==0){
                p[i][j-1]=1;
                if(index==word.length()-1){//找到这个单词就将flag置为1
                    flag=1;
                    return ;
                }
                dfs(board,word,p,index+1,i,j-1);


                p[i][j-1]=0;
            }
        }

        if(i+1<m&&flag==0){
            if(board[i+1][j]==word[index]&&p[i+1][j]==0){
                p[i+1][j]=1;
                if(index==word.length()-1){
                    flag=1;
                    return ;
                }
                dfs(board,word,p,index+1,i+1,j);
                p[i+1][j]=0;
            }
        }

        if(j+1<n&&flag==0){
            if(board[i][j+1]==word[index]&&p[i][j+1]==0){
                p[i][j+1]=1;

                if(index==word.length()-1){
                    flag=1;
                    return ;
                }
                dfs(board,word,p,index+1,i,j+1);
                p[i][j+1]=0;
            }
        }
    }
    /*void printarray(int **p,int m,int n)
    {
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++){
                cout<<p[i][j]<<" ";
            }
            cout<<endl;
        }

    }*/
};