面试题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

一、正确解法：回溯法

这是一道典型的矩阵搜索问题，和岛屿的最大面积这个题类似。需要从上下左右，四个方向去搜索字符串中的字符，我最开始想到的是循环，真的是向着相反的方向越走越远🤕，最后失败。这种矩阵搜索问题一般都要回溯，就是向上走不行的话，需要回到出发点，判断其他方向是否可以，解决这种回溯问题，必须要用到递归函数，那下面看一下思路。

我们要先想清楚递函数的要素：递归的参数，递归终止条件，递归内容和返回值：

1. 递归参数：需要递归的去比较字符串index位置的字符和数组board[i][j]是否相等，那么参数需要，数组，字符串，index下标，i 表示行，j 表示列。
2. 递归终止条件：什么时候结束递归，条件主要有，数组越界，字符和数组值不相等，字符串到达结尾。
3. 递归内容：
   （1）不能访问重复的元素，所以当我们访问一个元素时，就将它置为‘#‘，但是对于数组的比较不止一次，所以当一次判断完成后，应该将元素还原，我们引入变量temp。
   （2）需要和字符串的字符进行比较，那么设置下标index，比较一次index++，将字符串字符逐一判断。
   （3）需要从四个方向递归比较，只要有一个方向可以成功找到字符串即可，所以四个方向我们用【||】关系连接，那么有：上【dp(board,word,i-1,j,index) 】下 【dp(board,word,i+1,j,index)】左【dp(board,word,i,j-1,index)】右【dp(board,word,i,j+1,index))】
4. 返回值： 我们需要判断是否存在，所以用bool类型的返回值表示即可，那么我们判断四个方向比较的结果，为真那么返回真，否则为假。

那么我们主函数只需要循环数组，找到数组入口，调用递归函数即可，那么我们就拿上面的例子画图详细看一下过程：

那么代码就可以写出来了：

//2.df递归回溯
//递归退出条件：行列越界，字符串比较完成，在数组中找不到字符值
bool dp(vector<vector<char>>& board, string word,int i,int j,int index)
{
	if(i>=0 && i<board.size() && j>=0 && j<board[0].size() && board[i][j]==word[index])
	{
		index++;//index为字符下标
		if(index==word.size())//表示到达字符末尾了，已经处理结束
		{
			return true;
		}
		char temp=board[i][j];//保存数组原来的值，回溯时需要还原
		board[i][j]='#';//访问过了不能再访问。
		//上下左右递归判断,任何一条路径满足即可
		if(dp(board,word,i-1,j,index) || dp(board,word,i+1,j,index)||dp(board,word,i,j-1,index)||dp(board,word,i,j+1,index))
		{
			return true;
		}
		board[i][j]=temp;//回溯还原。
	}
	return false;
}
bool exist(vector<vector<char>>& board, string word) 
{
	if(board.empty())
		return false;
	for(int i=0;i<board.size();i++)
	{
		for(int j=0;j<board[i].size();j++)
		{
			if(board[i][j]==word[0])//找到入口,会存在多个入口
			{
				if(dp(board, word,i,j,0))
				{
					return true;
				}
			}
		}
	}
	return false;//没有找到入口
}
int main()
{
	vector<vector<char>> board;
	vector<char> temp;
	temp.push_back('C');
	temp.push_back('A');
	temp.push_back('A');
	board.push_back(temp);
	temp.clear();
	temp.push_back('A');
	temp.push_back('A');
	temp.push_back('A');
	board.push_back(temp);
	temp.clear();
	temp.push_back('B');
	temp.push_back('C');
	temp.push_back('D');
	board.push_back(temp);
	string word="AAB";
	cout<<exist(board,word); 

}

二、错误解法：for循环

这个解法是错误的，它不能处理回溯问题，但其他的情况都可以处理，我最开始写出来，然后一遍遍提交，就有些示例通不过，考虑到了特殊情况，如一个字符，字符串长数组短等问题，一直试，然后就一直不过，直到一个需要回溯的示例不能通过时，我才迷途知返😂，明白这个for循环是改不出来了，所以下次一定不要忘。

for循环的思路很简单：

• 先找到入口，找到后，就开始向上走，向下走，向左向右走，但是它每次只能走一个方向，所以不能回溯，就是向上走的字符不符合，回到原点继续别的方向，这个就不行了，它就会一直走，不会再回到原点。
• 最后判断字符串是否全部比较完成即可。
• 这个写四个方向寻找时，每个都要判断行列是否符合要求。

//1.for循环写法，错误，不能达到回溯的效果
bool exist1(vector<vector<char>>& board, string word) 
{
	if(board.empty())
		return false;
	vector<vector<char>> temp(board.size(),vector<char>(board[0].size()));//存储原数组的值，方便每次初始化
	//把board的值保存到temp中
	for(int i=0;i<board.size();i++)
	{
		for(int j=0;j<board[0].size();j++)
		{
			temp[i][j]=board[i][j];
		}
	}
	for(int i=0;i<board.size();i++)
	{
		for(int j=0;j<board[i].size();j++)
		{
			int index=0;
			if(board[i][j]==word[index])//找到入口,会存在多个入口
			{
				int h=i,k=j;//行列
				board[h][k]='#';//标志，不能再走了
				while(index<word.size()-1)//\0在最后一位存储，index从0开始的
				{
					index+=1;//和第1位，第2位……比较
					if(h<board.size() && k<board[0].size() &&h>0 && board[h-1][k]==word[index])
					{
						h-=1;
						board[h][k]='#';
						continue;
					}
					//向下走
					if(h<board.size()-1 && k<board[0].size()&& board[h+1][k]==word[index])
					{
						h+=1;
						board[h][k]='#';
						continue;
					}
					//向左走
					if(h<board.size() && k<board[0].size() &&k>0 && board[h][k-1]==word[index])
					{
						k-=1;
						board[h][k]='#';
						continue;
					}
					//向右走
					if(h<board.size() && k<board[0].size()-1&& board[h][k+1]==word[index])
					{
						k+=1;
						board[h][k]='#';
						continue;
					}
					if(word.size()!=1)//处理一位字符时，比如a,a是正确的
					{
						index-=1;//表示index位置的元素在数组中没有找到，处理字符串没有处理完
						//进入下一个入口，要初始化数组，把#变为原来的值
						for(int i=0;i<board.size();i++)
						{
							for(int j=0;j<board[0].size();j++)
							{
								board[i][j]=temp[i][j];
							}
						}
						break;//任何一步不符合则退出
					}
				}	
				if(index==word.size()-1)//判断是否字符找完了，处理字符比数组多的情况
				{
					return true;
				}
			}
		}
	}
	return false;//没有找到入口
}

这个for循环的解法错误，放上来警示警示。

加油哦！💪。