79. Word Search

79. Word Search

Problem:

Given a 2D board and a word, find if the word exists in the grid.

The word can be constructed from letters of sequentially adjacent cell, where “adjacent” cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once.

Example:

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

Given word = "ABCCED", return true.
Given word = "SEE", return true.
Given word = "ABCB", return false.

Analysis:

这种探索空间类型的问题，应该选用递归来解决。遍历矩阵，对每一个元素都设为为递归的入口，调用递归方程，判断是否匹配，如果匹配就一直递归直至整个单词的字母都被成功匹配。如果发现某个字母，比方说第三个单词 “ABCB” 中我们找到了 “C” 但是我们不能再找到接下来的 “B”， 所以我们返回 false。然后继续遍历其他的可能性能。

步骤0: 遍历矩阵
	步骤1: 调用递归方程 compare()
		步骤2: 判断单词是否全部被匹配，如果是，返回 true。否则就继续接下来的步骤
		步骤3: 判断元素是否越界；判断元素是否访问过；判断元素和字母是否相同。如果不通过，返回 false
		步骤4: 如果全部通过，对该元素四个邻居元素都调用 compare() 进行递归
			步骤5: 如果 compare() 有一个能返回 true，说明找到匹配的序列，我们返回 true 到上一层
			步骤6: 如果 compare() 一个都不能通过，那说明找不到匹配序列，我们返回 false 到上一层
	步骤7: 如果步骤1中的 compare() 返回 true，就说明可以找到匹配结果，否则就不行。

Solution:

方法1: 这个方法通过创建一个和原矩阵相同大小的矩阵来储存元素是否访问，但是遇到超大矩阵会超时，因此推荐方法2。利用 backtracking 的思路，在某个元素的位置对四周进行的探索时，把这个元素的值存在一个变量中，同时设置它为 '\0'，这样我们能省下很多的开销同时又能达到储存其访问信息的目的。如果这个元素最终发现并不能匹配单词，那我们就讲这个元素的值重新存回矩阵中，然后返回 false。

#include <iostream>
#include <vector>
#include <string>
#include "helperlib.hpp"

class Solution {
public:
    bool exist(std::vector<std::vector<char>>& board, std::string word) {
        m = board.size();
        if (m == 0) return false;
        n = board[0].size();
        if (n == 0) return false;
        
        // 步骤0: 遍历矩阵
        for (int i = 0; i < m; ++i)
        {
            for (int j = 0; j < n; ++ j)
            {
                int k = 0;
                std::vector<std::vector<bool>> visited(m, std::vector<bool>(n, false));
                
                // 步骤1: 调用递归方程 compare()
                if (compare(board, visited, word, i, j, k))
                {
                    // 步骤7: 如果步骤1中的 compare() 返回 true，就说明可以找到匹配结果，否则就不行。
                    return true;
                }
            }
        }
        return false;
    }
    
    bool compare(std::vector<std::vector<char>>& board,
                 std::vector<std::vector<bool>>& visited,
                 std::string& word,
                 int i,
                 int j,
                 int k)
    {
		// 步骤2: 判断单词是否全部被匹配，如果是，返回 true。否则就继续接下来的步骤
        if (k  == word.length())
        {
            return true;
        }
        
        // 步骤3: 判断元素是否越界；判断元素是否访问过；判断元素和字母是否相同。如果不通过，返回 false
        if (i < 0 || i >= m || j < 0 || j >= n)
        {
            return false;
        }
        
        if (board[i][j] == word[k] && !visited[i][j])
        {
            visited[i][j] = true;
            
      		// 步骤4: 如果全部通过，对该元素四个邻居元素都调用 compare() 进行递归
            if (compare(board, visited, word, i-1, j, k+1) ||
                compare(board, visited, word, i, j-1, k+1) ||
                compare(board, visited, word, i+1, j, k+1) ||
                compare(board, visited, word, i, j+1, k+1))
            {
       			// 步骤5: 如果 compare() 有一个能返回 true，说明找到匹配的序列，我们返回 true 到上一层
                return true;
            }
            else
            {
       			// 步骤6: 如果 compare() 一个都不能通过，那说明找不到匹配序列，我们返回 false 到上一层
                visited[i][j] = false;
                return false;
            }
        }
        else
        {
            return false;
        }
    }
    
private:
    int m;
    int n;
};

int main()
{
    std::vector<std::vector<char>> board = {
        {'A','B','C','E'},
        {'S','F','C','S'},
        {'A','D','E','E'}
    };

    std::string word = "ABCCED";

    Solution solution;

    bool result = solution.exist(board, word);

    print(result);

}

方法 2:

class Solution {
public:
    bool exist(std::vector<std::vector<char>>& board, std::string word) {
        m = board.size();
        if (m == 0) return false;
        n = board[0].size();
        if (n == 0) return false;
        
        for (int i = 0; i < m; ++i)
        {
            for (int j = 0; j < n; ++ j)
            {
                int k = 0;
                
                if (compare(board, word, i, j, k))
                {
                    return true;
                }
            }
        }
        return false;
    }
    
    bool compare(std::vector<std::vector<char>>& board,
                 std::string& word,
                 int i,
                 int j,
                 int k)
    {
        if (k  == word.length())
        {
            return true;
        }
        
        if (i < 0 || i >= m || j < 0 || j >= n)
        {
            return false;
        }
        
        if (board[i][j] == word[k])
        {
            int tmp = board[i][j];
            board[i][j] = '\0';
            
            ++k;

            if (compare(board, word, i-1, j, k) ||
                compare(board, word, i, j-1, k) ||
                compare(board, word, i+1, j, k) ||
                compare(board, word, i, j+1, k))
            {
                return true;
            }
            else
            {
                board[i][j] = tmp;
                return false;
            }
        }
        else
        {
            return false;
        }
    }
    
private:
    int m;
    int n;
};