Leetcode - Word Search I，II

Leetcode - 079. Word Search

我的思路:
1.首先得在board中寻找首元素可能出现的位置，对每个合法的开始位置进行dfs
2.每次dfs的过程中，结合backtracing避免回退

class Solution {
public:

    void dfs(vector<vector<char>>& board, string curs,int row,int col,int m ,int n,bool & status)
    {
        if (status)
            return;
        if (curs.length() <= 0)
        {
            status = true;
            return;
        }
        if (row < 0 || row >= m || col < 0 || col >= n)
        {
            return;
        }
        char ch = board[row][col];
        if (ch != curs[0])
            return;
        string s = curs.substr(1);
        board[row][col] = '.';
        dfs(board, s, row + 1, col, m, n, status);
        dfs(board, s, row - 1, col, m, n, status);
        dfs(board, s, row, col + 1, m, n, status);
        dfs(board, s, row, col - 1, m, n, status);
        board[row][col] = ch;
    }

    bool exist(vector<vector<char>>& board, string word) {
        int m = board.size();
        if (m <= 0)
            return false;
        int n = board[0].size();
        if (n <= 0)
            return false;
        int lens = word.length();
        if (lens <= 0)
            return true;
        for (int i = 0; i < m; ++i)
        {
            for (int j = 0; j < n; ++j)
            {
                char ch = board[i][j];
                if (ch == word[0])
                {
                    bool status = false;
                    dfs(board, word, i, j, m, n, status);
                    if (status)
                        return true;
                }
            }
        }
        return false;
    }
};

Leetcode - 212. Word Search II

diff : 出现的是一个word集合，将满足条件的word加入到结果中

需要做的是对集合中的每一个word均调用一次word search

Attention:这是一种比较死板的做法，实测Time ~ 1500ms 左右
只是在这个dfs + backtracing的专题内介绍这种模板的通用性写法
需要注意的几个可以优化的细节：
1.words可能会重复，去重的过程可以做优化
2.一个隐晦的细节(Note:You may assume that all inputs are consist of lowercase letters a-z.)，这个上题中没有提及的细节是本题优化的另一个方向
3.在(1.设置状态 2.dfs 3.恢复状态)的典型回溯过程中，若一个dfs函数得到可行解，那么则可跳过其他的dfs，直接恢复状态然后return

class Solution {
public:

    void dfs(vector<vector<char>>& board, string s, int row, int col, int m, int n,bool & status)
    {
        if (status)
            return;
        if (s.length() <= 0)
        {
            status = true;
            return;
        }
        if (row < 0 || row >= m || col < 0 || col >= n)
            return;
        char ch = board[row][col];
        if (ch != s[0])
            return;
        string str = s.substr(1);
        board[row][col] = '0';
        dfs(board, str, row + 1, col, m, n, status);
        dfs(board, str, row - 1, col, m, n, status);
        dfs(board, str, row, col + 1, m, n, status);
        dfs(board, str, row, col - 1, m, n, status);
        board[row][col] = ch;
    }

    bool helper(vector<vector<char>>& board, string curs)
    {
        int m = board.size();
        if (m <= 0)
            return false;
        int n = board[0].size();
        if (n <= 0)
            return false;
        if (curs.length() <= 0)
            return false;
        char ch = curs[0];
        for (int i = 0; i < m; ++i)
        {
            for (int j = 0; j < n; ++j)
            {
                if (ch == board[i][j])
                {
                    bool status = false;
                    dfs(board, curs, i, j, m, n, status);
                    if (status)
                        return true;
                }
            }
        }
        return false;
    }

    vector<string> findWords(vector<vector<char>>& board, vector<string>& words) {
        vector<string> vct;
        int words_len = words.size();
        if (words_len <= 0)
            return vct;
        sort(words.begin(), words.end());
        for (int i = 0;i < words_len;++i)
        {
            if (i > 0 && words[i] == words[i - 1])
                continue;
            if (helper(board, words[i]))
                vct.push_back(words[i]);
        }
        return vct;
    }
};