剑指 Offer 12. 矩阵中的路径

剑指 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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/ju-zhen-zhong-de-lu-jing-lcof

解法:

（1）.dfs+剪枝

思想：

找到符合要求的字符就从该字符的位置处开始搜索（上下左右），如果下一个搜索的结果也是我们需要的字符，则继续重复搜索，如果下一个搜索的结果不是我们需要的字符，则返回到上一个符合条件的位置，继续搜索

ps：

(1)搜索过程中我们需要注意搜索范围是整个矩阵，所以注意边界问题
(2)搜索过程中我们需要记录已经搜索过的方向，不然就会陷入无限循环和重复匹配问题

class Solution {
    public:
        bool exist(vector<vector<char> >& board, string word) {
            int rows = board.size(),cols = board[0].size();
             vector<vector<int> > visited(rows,vector<int>(cols,0));
            for(int i =  0; i < rows; i++)
                for (int j = 0; j < cols; j++)
                  if( dfs(board,i,j,0,word,visited))return true;            
            return false;
        }   
        bool dfs(vector<vector<char> >& board,int i ,int j,int index,string word,vector<vector<int> > &visited) 
        {   //i,j是在地图上的位置,index是要在word中匹配的索引位置
        
             //边界 
            if(i<0||j<0||i>board.size()-1||j>board[0].size()-1)    return false;
            //访问过
             if(visited[i][j]==1)return false;   
           	 bool isFindPath =false;

            if(board[i][j]==word[index])
            {  
   				//成功找到
                if(index==word.size()-1) //匹配完成
                return true;
                 index++;
                visited[i][j]=1;
         
            //上下左右dfs 
            isFindPath =  dfs(board,i,j-1,index,word,visited)||dfs(board,i-1,j,index,word,visited) 
            ||dfs(board,i+1,j,index,word,visited)||dfs(board,i,j+1,index,word,visited);

            if(isFindPath==false)
            {
                //回溯
                --index;
                visited[i][j]=0;
            }

            }
            return isFindPath;
        }
    };

提交之后，发现时间和内存使用都很巨大
执行用时: 404 ms
内存消耗: 177.1 MB

分析：

矩阵为m*n,word的长度为k

• 遍历的整个举证每次遍历k长，三个方向，时间复杂度为O(3^kmn);空间复杂度为递归的深度O(k)，最坏的情况k=mn。
• 代码结构写的有点断层，不是很清晰。

优化:

（1).不用visited,直接替换borad数组。
（2).优化边界
再次提交，依然很慢
最后在dfs的参数上对word加了个引用。飞起来了

class Solution {
    public:
        bool exist(vector<vector<char> >& board, string word) {
            int rows = board.size(),cols = board[0].size();
            for(int i =  0; i < rows; i++)
                for (int j = 0; j < cols ; j++)
                    if(dfs(board,i,j,0,word)) return true;
             return false;
        }   
        bool dfs(vector<vector<char> >& board,int i ,int j,int index,string word) 
        {   //i,j是在地图上的位置,index是要在word中匹配的索引位置
            
             //边界 或是未匹配 或访问过
            if(i<0||j<0||i>=board.size()||j>=board[0].size()||board[i][j]!=word[index])  return false;
            if(index==word.length()-1)  return true;        //成功找到    
            
            char temp = board[i][j];
             board[i][j]='\0';         //标记已访问
            //上下左右dfs 
            if(  
              dfs(board,i-1,j,index+1,word)
            ||dfs(board,i+1,j,index+1,word) 
            ||dfs(board,i,j-1,index+1,word)
            ||dfs(board,i,j+1,index+1,word))
             {
            // 当前元素的上下左右，如果有匹配到的，返回true
                return true;
             } 
              board[i][j]=temp;
            return false;
        }
    };

result:
执行用时: 20 ms
内存消耗: 7.5 MB