java矩阵最小路径和_矩阵中的路径(Java代码实现附思路)

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。下面给大家具体的分享了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 

{

for (int j = 0; 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 = 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 

{

for (int j = 0; 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 = rows || 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 

{

for (int j = 0; 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实例，请继续关注本站了解。