題目：

給定一個二維網格和一個單詞，找出該單詞是否存在於網格中。

單詞必須按照字母順序，通過相鄰的單元格內的字母構成，其中“相鄰”單元格是那些水平相鄰或垂直相鄰的單元格。同一個單元格內的字母不允許被重複使用。

示例:

board =
[
  ['A','B','C','E'],
  ['S','F','C','S'],
  ['A','D','E','E']
]

給定 word = "ABCCED", 返回 true.
給定 word = "SEE", 返回 true.
給定 word = "ABCB", 返回 false.

每天更新一道python or C++ leetcode題，力求講解清晰準確，客官們可以點贊或者關注。
 

演算法過程：（主要見程式碼註釋）

1.通過search函式的引數x, y記錄當前搜尋的位置，同時遍歷上下左右方向，進入下一個位置。進入時要考慮下個位置是否符合標準。（詳細解釋見程式碼）

2.已搜尋過的位置記為true,防止遞迴無法終止。搜尋完後重新標記為false。

程式碼：

python:(看著嚇人，實際邏輯很簡單）

class Solution:
    def __init__(self):
        self.pos = list()#
        self.n = self.m = 0#用來儲存行和列的數目
        self.flag = False#用來標誌最終結果
        self.l = 0#單詞長度
        self.target = ""#目標要構建的單詞
        self.direction = [[1,0],[-1,0],[0,1],[0,-1]]#可以選的方向
    def search(self, board, x, y, s):
        if s == self.target: self.flag = True; return#如果構建中的字串達到目標要構建的單詞
        if len(s) >= self.l: return#如果構建的字元的長度大了，就返回，防止無限增加
        self.pos[x][y] = True#把當前位置標記為已搜尋，防止再次搜尋。
        for d in self.direction:#遍歷所有方向，上下左右
            if 0 <= x+d[0] <= self.n-1 and 0 <= y+d[1] <= self.m-1 and not self.pos[x+d[0]][y+d[1]] and board[x+d[0]][y+d[1]] == self.target[len(s)]:#只有當下個節點沒有超過邊界並且沒有被訪問過並且是下一個必須的組成單詞的下一個字母時，我們才呼叫遞迴
                self.search(board, x+d[0], y+d[1], s+board[x+d[0]][y+d[1]])#構建中的單詞需要加上下一個字母，同時更新位置
                if self.flag: return#如果找到了該單詞，直接返回
        self.pos[x][y] = False#把當前標為未訪問

    def exist(self, board, word):
        self.n = len(board)#儲存行數
        if self.n == 0: return False
        self.m = len(board[0])#儲存列數
        if self.m == 0: return False
        self.l = len(word)#儲存單詞長度
        if self.l == 0 or self.l > self.n*self.m: return False#如果當前單詞比所有字母連一起還長
        self.target = word#儲存目標單詞
        self.pos = [[False for col in range(self.m)] for row in range(self.n)]#構建一個檢測有沒有被訪問的表
        for i in range(self.n):
            for j in range(self.m):
                if board[i][j] == word[0]:#如果當前字母等於第一個字母，開始遞迴
                    self.search(board,i,j,board[i][j])

        return self.flag#返回最終結果
 

C++(寫的相對簡潔一點)

class Solution {  
public:  
    bool exist(vector<vector<char>>& board, string word) {  
        int row = board.size();  
        int col = board[0].size();  
        for (int i = 0; i < row; i++)  
        {  
            for (int j = 0; j < col; j++)  
            {  
                //visit陣列記錄該陣列是否被訪問過  
                vector<vector<bool>> visit(row, vector<bool>(col, false));  
                bool res = dfs(board, visit, i, j, word, 0);  
                if (res == true)  
                    return true;  
            }  
        }  
        return false;  
    }  
    //index表示的是當前探索的是第幾個詞  
    bool dfs(vector<vector<char>>& b, vector<vector<bool>>& visit, int x, int y,                //遍歷陣列的每一點  
        string s, int index)  
    {  
        int row = b.size();  
        int col = b[0].size();  
        if (index == s.length())  
            return true;  
        //以下幾種情況 不再進行處理  
        //1、陣列越界  
        //2、該節點已經訪問過  
        //3、index位置的字元與字串中的字元不符  
        else if (x < 0 || x >= row || y < 0 || y >= col   //1  
                 || visit[x][y] == true                   //2  
                 || s[index]!=b[x][y])                    //3  
            return false;  
        else  
        {  
            visit[x][y] = true;  
            //從xy出發向周圍進行探索  
            bool x_1y = dfs(b, visit, x - 1, y, s, index + 1);  
            bool x1y = dfs(b, visit, x + 1, y, s, index + 1);  
            bool xy_1 = dfs(b, visit, x, y - 1, s, index + 1);  
            bool xy1 = dfs(b, visit, x, y + 1, s, index + 1);  
  
            if (x_1y || x1y || xy_1 || xy1)  
                return true;  
            else  
            {  
                visit[x][y] = false;  
                return false;  
            }  
        }  
    }  
};  
 

總結：

1.DFS可以通過記錄當前位置來達到深搜目的

2.用visited 陣列可以防止重複搜尋，無法結束遞迴

3.注意剪枝