DFS--矩阵中的最长递增路径（深搜+记忆化）

找一个矩阵中最长的递增路径，首先想到用dfs，然后这个题比较特殊的地方就是它要找到最长的，也就是说不得不遍历所有的位置，而对于每一个格子来说，并不是要求从它开始，不管从哪开始，这个格子对应的最长递增路径都是相同的，所以有点像动态规划，只不过是用备忘录的动态规划。
用一个max数组来记录每个点出发可以得到的最长路径，它是由周围的点得到的，如果max[i][j]不为0则进行dfs，因为在找一个的过程中会顺便把一些不可能符合的点赋值，从而减少复杂度。

进入dfs如果发现这个值被赋值过了不是0则直接返回这个位置的值。（dfs的结束条件变了，不是到达某个点，而是遍历所有的找到最大）
然后 先把这个地方的值先初始化为1，因为最差的情况就是四周的节点都大于这个值，则现在只能算出这的最长路径为1。
然后进行正常的向周围递归四次，得到新的x和y，如果newx和newy没有超过界限且此处的值大于原来x和y处的值，则令max[x,y]更新为此时的值和dfs(newx,newy)+1的最大值。

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.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){
                    dfs(i,j);
                }
            }
        }
        return maxLen;
    }
    public int dfs(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],dfs(newi,newj)+1);
            }
        }
        maxLen=Math.max(maxLen,max[i][j]);
        return max[i][j];
    }
    public boolean beyond(int x,int y){
        return(x<0 || y<0 || x>=matrix.length || y>=matrix[0].length);
    }
}