题目描述
请设计一个函数,用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始,每一步可以在矩阵中向左,向右,向上,向下移动一个格子。如果一条路径经过了矩阵中的某一个格子,则之后不能再次进入这个格子。 例如 a b c e s f c s a d e e 这样的3 X 4 矩阵中包含一条字符串"bcced"的路径,但是矩阵中不包含"abcb"路径,因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后,路径不能再次进入该格子。
c++实现
class Solution {
public:
bool hasPath(char* matrix, int rows, int cols, char* str)
{
if (matrix == NULL || rows < 1 || cols < 1 || str == NULL)
return false;
bool* visited = new bool[rows*cols];//定义一个辅助矩阵,用来标记路径是否已经进入了每个格子
memset(visited, 0, rows*cols);//对数组进行清零操作
int pathLength = 0;//
for (int row = 0;row < rows;++row)//该循环是为了实现从任何一个位置出发,寻找路径
{
for (int col = 0; col < cols;++col)
{
if (hasPathCore(matrix, rows, cols, row, col, str, pathLength, visited))
return true;
}
}
delete[] visited;
return false;
}
/*此函数用来判断在当前路径满足条件下,相邻格子中是否存在一个格子满足条件*/
bool hasPathCore(char* matrix, int rows, int cols, int row, int col, char* str, int& pathLength, bool* visited)
{
if (str[pathLength] == '\0')
return true;
bool hasPath = false;
if (row >= 0 && row < rows&&col >= 0 && col < cols&&matrix[row*cols + col] == str[pathLength] && !visited[row*cols + col])
{
++pathLength;
visited[row*cols + col] = true;
/*如果矩阵格子(row,col)与路径字符串中下标为pathLength的字符一样时,
从它的4个相邻格子中寻找与路径字符串下标为pathLength+1的字符相等的格子*/
hasPath = hasPathCore(matrix, rows, cols, row, col - 1, str, pathLength, visited) ||
hasPathCore(matrix, rows, cols, row - 1, col, str, pathLength, visited) ||
hasPathCore(matrix, rows, cols, row, col + 1, str, pathLength, visited) ||
hasPathCore(matrix, rows, cols, row + 1, col, str, pathLength, visited);
if (!hasPath)
{
--pathLength; //如果没找到,则说明当前第pathLength个字符定位不正确,返回上一个位置重新定位
visited[row*cols + col] = false;
}
}
return hasPath;
}
};
Java实现
public class Solution {
public boolean hasPath(char[] matrix, int rows, int cols, char[] str)
{
if (matrix == null || str == null || matrix.length < 1|| matrix.length<str.length) return false;
boolean[] visited = new boolean[rows*cols];
int curLength = 0;
for (int i = 0;i < rows;++i) {
for (int j = 0; j < cols; ++j) {
if (coreHasPath(matrix,rows,cols,i,j,str,visited,curLength)) return true;
}
}
return false;
}
private boolean coreHasPath(char[] matrix, int rows, int cols, int row, int col, char[] str, boolean[] visited, int curLength) {
if (curLength == str.length) return true;
boolean hasPath = false;
if (row>=0 && row < rows && col>=0 && col<cols && !visited[row*cols+col] && matrix[row*cols+col] == str[curLength]) {
curLength++;
visited[row*cols+col] = true;
hasPath = coreHasPath(matrix,rows,cols,row-1,col,str,visited,curLength) ||
coreHasPath(matrix,rows,cols,row+1,col,str,visited,curLength) ||
coreHasPath(matrix,rows,cols,row,col-1,str,visited,curLength) ||
coreHasPath(matrix,rows,cols,row,col+1,str,visited,curLength);
if (!hasPath) {
visited[row*cols+col] = false; //return hasPath回到上一层调用,curLength的值会自动回到上一层调用时的值
}
}
return hasPath;
}
}
python实现
# -*- coding:utf-8 -*-
class Solution:
def hasPath(self, matrix, rows, cols, path):
assistMatrix = [True]*rows*cols
for i in range(rows):
for j in range(cols):
if(self.hasPathCore(matrix,rows,cols, i, j, path, assistMatrix)):
return True
return False
def hasPathCore(self, matrix, rows, cols, i, j, path, assistMatrix):
if not path:
return True
index = i*cols+j
if i<0 or i>=rows or j<0 or j>=cols or matrix[index]!=path[0] or assistMatrix[index]==False:
return False
assistMatrix[index] = False
if(self.hasPathCore(matrix,rows,cols,i+1,j,path[1:],assistMatrix) or
self.hasPathCore(matrix,rows,cols,i-1,j,path[1:],assistMatrix) or
self.hasPathCore(matrix,rows,cols,i,j-1,path[1:],assistMatrix) or
self.hasPathCore(matrix,rows,cols,i,j+1,path[1:],assistMatrix)):
return True
assistMatrix[index] = True
return False
# write code here