请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。下面给大家具体的分享了3种实现方法和思路。
路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。
假如一条路径经过了矩阵中的某一个格子，那么这条路径不能再进入这个格子。
例：
矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。
思路1：（思路非常清楚）
回溯
基本思想：
0.根据给定数组，初始化一个标志位数组，初始化为false，表示未走过，true表示已经走过，不能走第二次
1.根据行数和列数，遍历数组，先找到一个与str字符串的第一个元素相匹配的矩阵元素，进入judge
2.根据i和j先确定一维数组的位置，因为给定的matrix是一个一维数组
3.确定递归终止条件：越界，当前找到的矩阵值不等于数组对应位置的值，已经走过的，这三类情况，都直接false，说明这条路不通
4.若k，就是待判定的字符串str的索引已经判断到了最后一位，此时说明是匹配成功的
5.下面就是本题的精髓，递归不断地寻找周围四个格子是否符合条件，只要有一个格子符合条件，就继续再找这个符合条件的格子的四周是否存在符合条件的格子，直到k到达末尾或者不满足递归条件就停止。
6.走到这一步，说明本次是不成功的，我们要还原一下标志位数组index处的标志位，进入下一轮的判断。
public class Solution
{
public boolean hasPath(char[] matrix, int rows, int cols, char[] str)
{
//标志位，初始化为false
boolean[] flag = new boolean[matrix.length];
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
{
//循环遍历二维数组，找到起点等于str第一个元素的值，再递归判断四周是否有符合条件的----回溯法
if (judge(matrix, i, j, rows, cols, flag, str, 0))
{
return true;
}
}
}
return false;
}
//judge(初始矩阵，索引行坐标i，索引纵坐标j，矩阵行数，矩阵列数，待判断的字符串，字符串索引初始为0即先判断字符串的第一位)
private boolean judge(char[] matrix, int i, int j, int rows, int cols, boolean[] flag, char[] str, int k)
{
//先根据i和j计算匹配的第一个元素转为一维数组的位置
int index = i * cols + j;
//递归终止条件
if (i < 0 || j < 0 || i >= rows || j >= cols || matrix[index] != str[k] || flag[index] == true)
return false;
//若k已经到达str末尾了，说明之前的都已经匹配成功了，直接返回true即可
if (k == str.length - 1)
return true;
//要走的第一个位置置为true，表示已经走过了
flag[index] = true;
//回溯，递归寻找，每次找到了就给k加一，找不到，还原
if (judge(matrix, i - 1, j, rows, cols, flag, str, k + 1) ||
judge(matrix, i + 1, j, rows, cols, flag, str, k + 1) ||
judge(matrix, i, j - 1, rows, cols, flag, str, k + 1) ||
judge(matrix, i, j + 1, rows, cols, flag, str, k + 1))
{
return true;
}
//走到这，说明这一条路不通，还原，再试其他的路径
flag[index] = false;
return false;
}
}思路2：
/**
用一个状态数组保存之前访问过的字符，然后再分别按上，下，左，右递归
*/
public class Solution
{
public boolean hasPath(char[] matrix, int rows, int cols, char[] str)
{
int flag[] = new int[matrix.length];
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
{
if (helper(matrix, rows, cols, i, j, str, 0, flag))
return true;
}
}
return false;
}
private boolean helper(char[] matrix, int rows, int cols, int i, int j, char[] str, int k, int[] flag)
{
int index = i * cols + j;
if (i < 0 || i >= rows || j < 0 || j >= cols || matrix[index] != str[k] || flag[index] == 1)
return false;
if (k == str.length - 1) return true;
flag[index] = 1;
if (helper(matrix, rows, cols, i - 1, j, str, k + 1, flag) ||
helper(matrix, rows, cols, i + 1, j, str, k + 1, flag) ||
helper(matrix, rows, cols, i, j - 1, str, k + 1, flag) ||
helper(matrix, rows, cols, i, j + 1, str, k + 1, flag))
{
return true;
}
flag[index] = 0;
return false;
}
}思路3：
1、每次执行DFS先判断走过的路径是不是等于要求的路径，是就返回结果true，不是就继续找。
2、先判断当前点是否可走，不是，则返回上一层;是就顺时针探寻下一个方位的结点(上、右、下、左)，以下一个方位结点进行DFS，如果方位都探完了还找不到路径，那么当前节点不可能是路径结点之一，只能返回上一层。
public class Solution
{
private boolean visited[] = null; //标志每个位置是否走过，true走过，false没走过
public boolean hasPath(char[] matrix, int rows, int cols, char[] str)
{
if (matrix == null || str == null || str.length > matrix.length || rows * cols != matrix.length)
//进行非法性判断
return false;
//初始化visited数组
visited = new boolean[rows * cols];
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
{
//以每个结点作为起始节点去dfs
if (dfs(matrix, i, j, rows, cols, str, 0))
return true;
}
}
//没有找到
return false;
}
/**
* @param matrix 地图
* @param x 起点x
* @param y 起点y
* @param rows 行数
* @param cols 列数
* @param str 所求路径
* @param len 当前已经找到路径的长度
* @return
*/
private boolean dfs(char[] matrix, int x, int y, int rows, int cols, char[] str, int len)
{
if (len >= str.length)
{
//找到要求的路径
return true;
}
else
{
//路径长度小于要求的长度，还得继续寻找
if (x >= 0 && x <= rows - 1 && y >= 0 && y <= cols - 1 && visited[x * cols + y] == false && matrix[x * cols + y] == str[len])
{
//当前结点是路径节点之一
visited[x * cols + y] = true; //把当前结点的标志位设为true，证明走过了
//寻找下一方位
int dict = 0;
int x1 = 0, y1 = 0;
while (dict <= 3)
{
switch (dict)
{
case 0:
x1 = x - 1;
y1 = y;
break;
case 1:
x1 = x;
y1 = y + 1;
break;
case 2:
x1 = x + 1;
y1 = y;
break;
case 3:
x1 = x;
y1 = y - 1;
break;
}
if (dfs(matrix, x1, y1, rows, cols, str, len + 1)) //判断下一个方位能否找到路径
return true; //能，直接返回
dict++; //不能，找下一方位
}
//不能从当前结点找不到路径，那就回溯，把当前结点标志位设为false
visited[x * cols + y] = false;
return false; //返回失败
}
else
{
//当前结点不是要找的路径，直接回溯
return false;
}
}
}
}以上实现方式和思路大家都清楚了吗？更多java实例，请继续关注本站了解。