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

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

示例:

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

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

提示：

board 和 word 中只包含大寫和小寫英文字母。
1 <= board.length <= 200
1 <= board[i].length <= 200
1 <= word.length <= 10^3

思路

遞迴改非遞迴是真的難。。。

#define PII pair<int, int>

class Solution {
public:
    
    bool dfs(vector<vector<char>> &board, string &word){
        int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
        bool st[210][210];
        vector<PII> stk;
        vector<int> idx;

        int m = board.size(), n = board[0].size();

        for(int i = 0; i < m; i ++)
            for(int j = 0; j < n; j ++){
                if(board[i][j] == word[0]){
                    
                    memset(st, 0, sizeof st);
                    
                    stk.clear(), idx.clear();
                    stk.push_back({i, j});
                    
                    st[i][j] = 1;
                    
                    int s = 0;

                    while(stk.size()){
                        if(stk.size() == word.size()) return 1;
                        auto t = stk.back();
                        int x = t.first, y = t.second;

                        int flag = 0;
                        for(int i = s; i < 4; i ++){
                            int a = x + dx[i], b = y + dy[i];
                            if(a < 0 || a >= m || b < 0 || b >= n) continue;
                            if(st[a][b] || board[a][b] != word[stk.size()]) continue;
                            
                            s = 0;
                            flag = 1;
                            st[a][b] = 1;
                            idx.push_back(i + 1);
                            stk.push_back({a, b});
                            
                            break;
                        }
                        
                        if(!flag){
                            st[x][y] = 0;
                            stk.pop_back();
                            if(idx.size()){
                                s = idx.back();
                                idx.pop_back();
                            } 
                        }
                    }
                }
            }
            return 0;
    }

    bool exist(vector<vector<char>>& board, string word) {

        return dfs(board, word);
    }
};