普通dfs

找到一个数组中的最长的路径
第一个想法是dfs，深度遍历回溯每一个格子的上下左右格子，更新最长路径，遍历完所有的则遍历完成
遍历的途中就是dfs（i，j，x）
i，j分别是此时矩阵的坐标，数组可以创建一个外部数组这样就不用每次传数组了，然后进入dfs，首先进行判断是否越界，越界则返回，然后进行四次dfs，这个dfs的过程中在外界定义一个dir双层数组，里面包含｛1,0｝，｛0,1｝，｛-1,0｝，｛0，-1｝四个数组，这样就可以在dfs时通过for循环四次。每次x和y都加这个数组中的值来直接得到加过的x和y值，因为加完之后要进行判断而不是直接传进去了，所以这样就很方便。
得到加过的x和y后进行是否越界的判断和新的矩阵的值是否大于此时矩阵的值的判断，符合则直接传进去。
但是这样的缺点是java会超过时间过不了

改进

用一个max数组来记录每个点出发可以得到的最长路径，用一个函数来得到从i，j出发的最短路径，如果max[i][j]不为0则进行这个函数，因为在找一个的过程中会顺便把一些不可能符合的点赋值，从而减少复杂度。
然后在递归的过程中发现这个值被赋值过了不是0则直接返回这个位置的值。然后将这个位置的max赋值为1，然后for循环四次，得到新的x和y，如果newx和newy没有超过界限且此处的值大于原来x和y处的值，则令max[x,y]更新为此时的值和core(newx,newy)+1的最大值，与直接的做法不同就是会维护max数组，这样就是有记忆的，可以节省很多没有必要的步骤。

class Solution {
    int[][] max;
    int[][] matrix;
    int[][] flag={{0,1},{1,0},{-1,0},{0,-1}};
    int maxLen=0;
    public int longestIncreasingPath(int[][] matrix) {
        if(matrix==null || matrix.length==0){
            return 0;
        }
        max=new int[matrix.length][matrix[0].length];
        this.matrix=matrix;
        for(int i=0;i<matrix.length;i++){
            for(int j=0;j<matrix[0].length;j++){
                if(max[i][j]==0){
                    core(i,j);
                }
            }
        }
        return maxLen;
    }
    public int core(int i,int j){
        if(max[i][j]!=0){
            return max[i][j];
        }
        max[i][j]=1;
        for(int x=0;x<4;x++){
            int newi=i+flag[x][0];
            int newj=j+flag[x][1];
            if(beyond(newi,newj)&&matrix[newi][newj]>matrix[i][j]){
                max[i][j]=Math.max(max[i][j],core(newi,newj)+1);
            }
        }
        maxLen=Math.max(maxLen,max[i][j]);
        return max[i][j];
    }
    public boolean beyond(int x,int y){
        if(x<0 || y<0 || x>=matrix.length || y>=matrix[0].length){
            return false;
        }else{
            return true;
        }
    }
}

标签：return,matrix,int,max,dfs,DFS1,数组,回溯
来源： https://blog.csdn.net/weixin_47040809/article/details/112388248