一刷306-dp-剑指 Offer II 112. 最长递增路径（同：329. 矩阵中的最长递增路径）

题目：
给定一个 m x n 整数矩阵 matrix ，找出其中 最长递增路径 的长度。

对于每个单元格，你可以往上，下，左，右四个方向移动。 
不能 在 对角线 方向上移动或移动到 边界外（即不允许环绕）。

输入：matrix = [[9,9,4],[6,6,8],[2,1,1]]
输出：4 
解释：最长递增路径为 [1, 2, 6, 9]。

输入：matrix = [[3,4,5],[3,2,6],[2,2,1]]
输出：4 
解释：最长递增路径是 [3, 4, 5, 6]。注意不允许在对角线方向上移动。
示例 3：

输入：matrix = [[1]]
输出：1
 
提示：
m == matrix.length
n == matrix[i].length
1 <= m, n <= 200
0 <= matrix[i][j] <= 231 - 1
--------------
思路：
我们首先可以写一个常规的DFS算法：遍历每一个单元格，以此为起点，
不断地向四周搜索比当前单元格大的单元格，再以下一个单元格 
（这个单元格不会回到前一个单元格，想想为什么？） 为起点，
重复上述过程的同时不断更新从最初的起点到当前单元格的最长递增距离。

但是每遇到一个单元格都必须向周围搜索吗？答案显然否定的。再看一下上述常规的DFS算法，
设当前单元格为current，其周围的单元格为next，
上述搜索过程就是我们站在current向周围的单元格next提出了一个问题：如果你比我大，
那么以你为起点的最长递增路径长度是多少？当然，如果next较小的话，自然next向current回答长度为0。 
我们需要注意到next回答这个问题根本就不在乎是哪个方向问的。

所以，如果我们在之前的DFS时已经知晓了以某一个单元为起点的最长递增路径长度，就把它存下来，
当我们后续遍历到这个节点的时候就可以直接使用这个值了。

以上就是记忆化搜索的思路，我们设 dp[i][j] 表示由matrix[i][j]为起点出发的最长上升序列长度，
那么当我们遍历时发现dp[i][j] > 0就知道这个单元格遍历过了，直接使用这个值就行了；
否则就需要常规的深度优先搜索。
----------------------
class Solution {//dp[i][j] : 由(i, j) 出发的最长上升序列长度
    int[][] dp;//定义dp二维数组
    public int longestIncreasingPath(int[][] matrix) {
        int row = matrix.length;//获取矩阵的 行列值
        int col = matrix[0].length;
        dp = new int[row][col];//初始化dp数组
        int res = 0;//结果集
        for (int i = 0; i < row; i++) {//遍历行
            for (int j = 0;  j < col; j++) {//遍历列
                res = Math.max(res, backTracking(matrix, row, col, i, j, -1));//dfs
            }
        }
        return res;
    }
    private int backTracking(int[][] matrix, int row, int col, int x, int y, int pre) {
        if (x < 0 || x >= row || y < 0 || y >= col) return 0;//特判
        int cur = matrix[x][y];//获取当前在 矩阵中的值
        if (cur <= pre) return 0;//特判 若当前值小于 路径中上一个值， return 0
        if (dp[x][y] > 0) return dp[x][y];
        int up = backTracking(matrix, row, col, x - 1, y, cur);//四个方向递归
        int down = backTracking(matrix, row, col, x + 1, y, cur);
        int left = backTracking(matrix, row, col, x, y - 1, cur);
        int right = backTracking(matrix, row, col, x, y + 1, cur);
        int max = Math.max(Math.max(up, down), Math.max(left, right));//找到最大的当前值
        dp[x][y] = max + 1;//保存数据
        return max + 1;
    }
}
//dfs：返回由下一个节点出发能够到达的最长上升序列长度

LC