矩阵中的路径 AcWing (JAVA)

请设计一个函数，用来判断在一个矩阵中是否存在一条路径包含的字符按访问顺序连在一起恰好为给定字符串。

路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。

如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。

注意：

输入的路径字符串不为空； 所有出现的字符均为大写英文字母；
数据范围 矩阵中元素的总个数 [0,900] 。
路径字符串的总长度 [1,900] 。

样例：

matrix= [
[“A”,“B”,“C”,“E”],
[“S”,“F”,“C”,“S”],
[“A”,“D”,“E”,“E”]
]

str=“BCCE” , return “true”

str=“ASAE” , return “false”

解题思路： 本题思路是一个典型的迷宫问题的衍生题。核心思路依旧是 递归与回溯也就是暴力破解法。
(如果对回溯没有概念的话，可以看看这个大哥的视频，讲的是真不错，不懂可以反复观看和模拟：回溯问题）
本题的大致解题过程也很清晰：
1 . 首先从矩阵左上角开始，选一个字母作为路径 起点，判断是否和给定字符串 str 第一个字符一样，如果不一样就在矩阵中按顺序选下一个字符直到一样为止。再对选取字符进行标记： （这需要两个for循环）
2 . 利用递归继续以上一次选取字符位置为起点，进行左右上下探索，如果探索的字符与str的第二个字符一样，那么就对矩阵中此字符标记为已经来过，并以此字符为新起点继续递归探索下面的字符，并以此类推继续执行第 2 步。
(如果左右上下的探索中都没有符合条件的字符，那么就可以结束本次探索，解除对矩阵中上一个字符的标记（回溯）并执行第 1 步开始新的探索。）

解题方式可以用树来操作：

理论成立代码如下（正确代码）：

class Solution {
    public boolean hasPath(char[][] matrix, String str) {
           for(int i = 0; i < matrix.length; i ++) {
        	   for(int j = 0; j < matrix[0].length; j ++) {//按顺序选取起点
        		   char a = matrix[i][j];//记录本字符
        		   if(dfs(matrix, i, j, 0, str)) return true;//存在一条符合的路径即可退出
        		   matrix[i][j] = a;//回溯
        	   }
        	  
           }
           return false;//没有一条符合条件的路径那么返回false
    }
    public boolean dfs(char matrix[][], int i, int j, int k, String str) {
    	if(matrix[i][j] != str.charAt(k)) return false;//不相同直接退出
    	if(k == str.length() - 1) return true;//上一个条件说明对应字符相等，此条件判断此字符是否是最后一个字符，是的话直接退出
    	matrix[i][j] = 1;//标记此字符已经访问过，继续下次的探索
    	int fx[] = {0, 0, -1, 1};
    	int fy[] = {-1, 1, 0, 0};//左右上下四个新探索方向
    	int fxx = 0, fyy = 0;
    	for(int z = 0; z < 4; z ++) {
    		fxx = i + fx[z];
    		fyy = j + fy[z];
    		if(fxx >= 0 && fxx < matrix.length && fyy >= 0 && fyy < matrix[0].length && matrix[fxx][fyy] != 1) {
    		   //需要判断新方向是否超出矩阵边界，是否已经被访问过，不符合条件则不探索
    			char a = matrix[fxx][fyy];
    		   if(dfs(matrix, fxx, fyy, k + 1, str)) return true;//路径存在直接退出返回true
    		   matrix[fxx][fyy] = a;//回溯
    		}
    	}
    	return false;//路径不存在，继续找下一个新起点。
    }
}

***************************************************************************************************************************

进阶：由于最后一个测试点数据庞大，如果在发现路径后，不直接退出，而是对路径回溯的话，那么就会超时。超时代码如下：

import java.util.*;

public class Main {
	 
    public static void main(String[] args) {
     Solution s = new Solution();
     char a[][]= {{'A', 'B', 'C', 'E'},
    		      {'S', 'F', 'C', 'S'},
    		      {'A', 'D', 'E', 'E'},
    		       };
    
     System.out.println(s.hasPath(a, "BCCE"));
     //System.out.print();
     for(int i = 0 ; i < a.length; i ++) {
    	 for(int j = 0; j < a[0].length; j ++) {
    		 System.out.print(a[i][j] + " ");
    	 }
    	 System.out.println();
     }
 	  }
 
}
class Solution {
    public boolean hasPath(char[][] matrix, String str) {
    	if(matrix.length == 0)
    		return false;
        for(int i = 0; i < matrix.length; i ++) {
        	for(int j = 0; j < matrix[0].length; j ++) {
        		char a = matrix[i][j];
        		if(dfs(matrix, i, j, 0, str))  return true;
        		matrix[i][j] = a;
        	}
        }
        return false;
    }
    public boolean dfs(char matrix [][],int i, int j, int k, String str) {
    	   boolean judge = false;
    	   if(k == str.length()) return false;
    	   if(str.charAt(k) == matrix [i][j]) {
    	   if(k == str.length() - 1 && matrix[i][j] == str.charAt(k)) return true;
    	   }
    	   else
    	   return false;
    	   matrix[i][j] = 1;
    	   int fx[] = {0, 0, -1, 1};
    	   int fy[] = {-1, 1, 0, 0};
    	   int fxx = 0; int fyy = 0;
    	   for(int x = 0; x < 4; x ++) { 
    		   fxx = i + fx[x];
    		   fyy = j + fy[x];
    		   if(fxx >= 0 && fxx < matrix.length && fyy >= 0 && fyy < matrix[0].length && matrix[fxx][fyy] != 1) {         			   
    			   char a = matrix[fxx][fyy];
    			   if(dfs(matrix , fxx, fyy, k + 1, str))  judge = true;
    			   matrix[fxx][fyy] = a;
    		   }
    	   }
    	   return judge;
    }
}

上述方法运行结果如下：

由于最后一个测试点，数据量庞大，而且找到正确路径后数组的状态对我们来说已经不重要了，所以找到正确路径后跟本没必要回溯。

第一个正确代码运行结果如下所示：

第一个代码在发现有正确路径后直接走人，很潇洒，所以运行时间会比第二个超时代码快，而且刚好不会超时。