題目大意：

　　給出一個二維陣列，再給出一個字串，試問該字串是否存在於這個二維陣列中？

題目說明：

　　所謂“字串存在於二維陣列中”，即從二維陣列的任一元素出發，從上下左右四個方向“前進”，直到找到整條字串。如下：
　　輸入：[[‘A’,’B’,’C’,’E’], [‘S’,’F’,’C’,’S’], [‘A’,’D’,’E’,’E’]]，構成的二維陣列可以寫成矩陣形式：

　　如果此時給定的字串是”ABCCED”或”SEE”，則應當輸出”true”。若給定字串是”ABCB”，應當輸出”false”，因為在這個二維陣列中找不到連續的’A’、’B’、’C’和’B’組成的字串。
　　要說明的是，二維陣列中同一位置的字元不能重複使用兩次。

解題思路

　　剛看到這道題，就能明確這是一道用BFS解決的題目。解題思路也很清晰：遍歷二維陣列，從當前點出發，比較所在點的字元與給定字串當前位置的字元是否相等，若相等，則向四個方向前進，並把字串的“當前位置”向後推移一位，直到達到字串末尾。具體操作起來，在“前進”過程中，維護合法字串長的最大值，一旦它與給定字串的長度相等，則說明存在。
　　為保證同一個字元不會被使用兩次，用陣列flag記錄每一個位置上字元的使用情況。具體實現如下：

class Solution {
public:
    int row,column;
    int flag[1000][1000];
    int comp(int
 
 a,int b,int c,int d)
    {
        int k;
        k=(a>=b?a:b);
        k=(k>=c?k:c);
        k=(k>=d?k:d);
        return k;
    }
    int check(int i,int j, int seq, vector< vector<char> >& board, string word)
    {
        if(i>=0&&i<row&&j>=0&&j<column&&flag[i][j]==0
 
&&seq<word.size())  //未超邊界，未訪問過且字元相等
        {
            char c;
            c=board[i][j];  //取i,j處的值
            if(c==word.at(seq))
            {
                flag[i][j]=1;
                return comp(check(i+1,j,seq+1,board,word)+1,check(i,j+1,seq+1,board,word)+1,check(i-1,j,seq+1,board,word)+1,check(i,j-1,seq+1,board,word)+1);
            }
            else
                return 0;
        }
        else
            return 0;
    }
    bool exist(vector<vector<char>>& board, string word) {
    int number,num;
    column=board[0].size();  //列數
    row=board.size();  //行數
    num=word.size();
    for(int i=0;i<row;i++)  //逐個遍歷
    for(int j=0;j<column;j++)
    {
        memset(flag,0,sizeof(flag));  //將標誌陣列初始化
        number=check(i,j,0,board,word);
        if(number==num) return true;
    }
    return false;
    }
};

　　不幸的是，上傳程式碼後只得到了WA。仔細檢查，發現問題就出在flag陣列的更新上。以如下的二維陣列為例：
　　
　　給定字串是”ABCESEEEFS”。可以發現，在程式按A(1,1)-B-C-E(2,3)-S-E(3,4)-E(3,3)的路線走後，發現再也沒有與給定字串匹配的路線。此時，由於(2,3)和(3,3)處的flag值被設為1，程式再也返回不到(1,3)處的C，從而使得結果輸出錯誤。
　　要解決這一問題，必須在“此路不通”的情況下，修改flag的值，使得程式能返回到“岔路口”。參考了discuss中的結果，修改程式如下：

class Solution {
public:
    int row,column;
    int flag[1000][1000];
    bool check(int i,int j, int seq, vector< vector<char> >& board, string word)
    {
        if(i<0||i>=row||j<0||j>=column||flag[i][j]==1||board[i][j]!=word.at(seq))  //超邊界，訪問過或者不相等
            return false;
        char c;
        if(seq==word.size()-1) return true;  //如果是最後一個字元，則直接返回true
        c=board[i][j];  //否則，取(i,j)處的值
        flag[i][j]=1;
        if(check(i+1,j,seq+1,board,word)||check(i,j+1,seq+1,board,word)||check(i-1,j,seq+1,board,word)||check(i,j-1,seq+1,board,word))  //只要有一項成立即可，否則，需將標誌改回來，再返回false，表示此路不通
            return true;
        flag[i][j]=0;   
        return false;
    }
    bool exist(vector<vector<char>>& board, string word) {
    bool jud;
    column=board[0].size();  //列數
    row=board.size();  //行數
    for(int i=0;i<row;i++)  //逐個遍歷
    for(int j=0;j<column;j++)
    {
        memset(flag,0,sizeof(flag));  //將標誌陣列初始化
        jud=check(i,j,0,board,word);
        if(jud) return true;
    }
    return false;
    }
};

　　這次不用長度作為判斷是否存在標誌，而是直接將搜尋結果返回。但執行的結果卻是超時。仔細對比了修改的程式與discuss中給出的程式，發現差別主要在於：自己寫的程式中用到了新建的陣列flag，每遍歷一個位置的字元時就要將其重新初始化為0，而discuss中的程式則是將修改flag值的操作改成修改board陣列相應位置元素為’/0’的操作，這樣就少了將flag整體賦為0的步驟，整體降低了時間複雜度。
　　需要說明的是，雖然引用傳遞會改變實參（本問題中即原二維陣列board）的值，但在程式中已經做了相應的處理：對每條走不通路徑上的值都將其還原。這樣，就不用擔心每遍歷一次，原陣列的值修改一次的問題了。程式碼如下：

   class Solution {
    public:
         bool exist(vector<vector<char> > &board, string word) {
             m=board.size();
             n=board[0].size();
            for(int x=0;x<m;x++)
                for(int y=0;y<n;y++)
                {
                    if(isFound(board,word.c_str(),x,y))
                        return true;
                }
            return false;
        }
    private:
        int m;
        int n;
        bool isFound(vector<vector<char> > &board, const char* w, int x, int y)
        {
            if(x<0||y<0||x>=m||y>=n||board[x][y]=='\0'||*w!=board[x][y])
                return false;
            if(*(w+1)=='\0')
                return true;
            char t=board[x][y];
            board[x][y]='\0';
            if(isFound(board,w+1,x-1,y)||isFound(board,w+1,x+1,y)||isFound(board,w+1,x,y-1)||isFound(board,w+1,x,y+1))
                return true; 
            board[x][y]=t;  //將值還原
            return false;
        }
    };

　　這道題目雖然只是BFS的一道簡單應用題，但背後需要注意的細節其實很多。這提醒我在編寫程式的時候一定要提前把所有要注意到的方面想清楚，這樣才能事半功倍。