剑指 Offer 12. 矩阵中的路径

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。

[[“a”,“b”,“c”,“e”],
[“s”,“f”,“c”,“s”],
[“a”,“d”,“e”,“e”]]

但矩阵中不包含字符串“abfb”的路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入这个格子。

示例 1：

输入：board = [[“A”,“B”,“C”,“E”],[“S”,“F”,“C”,“S”],[“A”,“D”,“E”,“E”]], word = “ABCCED”
输出：true

示例 2：

输入：board = [[“a”,“b”],[“c”,“d”]], word = “abcd”
输出：false

提示：

1 <= board.length <= 200
1 <= board[i].length <= 200

我的思路

进行一次深度优先搜索，但从结果来看虽然可以AC可是效率很低。

代码展示

class Solution
{
private:
    int a[205][205]={0};

public:
    bool found(vector<vector<char>> board, string word, int x, int y, int num)
    {
        if (num == word.length())
            return true;

        if (x > 0 && a[x - 1][y] == 0 && board[x - 1][y] == word[num])
        {
            a[x - 1][y]  = 1;
            if(found(board, word, x - 1, y, num + 1))return true;
            a[x - 1][y]  = 0;
        }

        if (x < board.size() - 1 && a[x + 1][y] == 0 && board[x + 1][y] == word[num])
        {
            a[x + 1][y]= 1;
            if(found(board, word, x + 1, y, num + 1))return true;
            a[x + 1][y]= 0;
        }

        if (y > 0 && a[x][y - 1] == 0 && board[x][y - 1] == word[num])
        {
            a[x][y - 1] = 1;
            if(found(board, word, x, y - 1, num + 1))return true;
            a[x][y - 1] = 0;
        }

        if (y < board[0].size()-1 && a[x][y + 1] == 0 && board[x][y + 1] == word[num])
        {
            a[x][y + 1] = 1;
            if(found(board, word, x, y + 1, num + 1))return true;
            a[x][y + 1] = 0;
        }

        return false;
    }

    bool exist(vector<vector<char>> &board, string word)
    {    
        for (int i = 0; i < board.size(); i++)
        {
            for (int j = 0; j < board[0].size(); j++)
            {
                if (board[i][j] == word[0])
                {
                    a[i][j] = 1;
                    if (found(board, word, i, j, 1))
                        return true;
                    a[i][j] = 0;
                }
            }
        }

        return false;
    }
};

优化思路

• 舍弃了使用辅助函数来确认是否走过路径的方法，转而改变board字符串数组来达到记录的目的。
• 不再一开始判断是否可以走过，而是走了以后再进行判断是否合适

与上面代码对比：运行时间少了27.3倍，内存占用少了28.93倍，值得学习一番

改进后的代码

class Solution {
public:
    bool exist(vector<vector<char>>& board, string word) {
        if(board.size() == 0) return false;
        for (int i=0;i<board.size();i++){
            for(int j=0;j<board[0].size();j++){
                if (dfs(board,word,i,j,0)){
                    return true;
                }
            }
        }
        return false;
    }

    bool dfs(vector<vector<char>>& board, string& word, int i,int j,int length){
        if(i>=board.size()||j>=board[0].size()||i<0||j<0||length>=word.size()||word[length]!=board[i][j]){
            return false;
        }
        if(length==word.size()-1&&word[length]==board[i][j]){
            return true;
        }
        char temp=board[i][j];
        board[i][j]='0';
        bool flag=dfs(board,word,i,j+1,length+1)||dfs(board,word,i,j-1,length+1)||dfs(board,word,i+1,j,length+1)||dfs(board,word,i-1,j,length+1);
        board[i][j]=temp;
        return flag;
    }
};