Leetcode--Java--329. 矩阵中的最长递增路径

题目描述

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

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

样例描述

思路

方法一：DFS（递归回溯） + 记忆化搜索

1. 遍历枚举每个点作为起点，进行DFS回溯，取其中所有路径最大的。
2. 在DFS中进行记忆化，就是存下每个点的能够达到的最大长度。如果后续在遍历四个方向中碰到重复的结点就直接返回。对于每次DFS，遍历枚举四个方向，然后枚举下一层的时候加上1，表示加上当前的路径，注意要和原来的取max，因为这条路径最终的长度不一定比原来的长。
3. 最后DFS记得记忆化存储当前这层i，j的结果。

方法二：dp的记忆化搜索写法

1. 先考虑dp，以f[i,j]表示以（i，j为起点的上升路径最大长度）
   
2. 由于是严格上升，所以肯定不存在环，否则有矛盾。如果不是严格上升，就不能用dp做，只能用图论的方法来写。
3. 方法二的代码与方法一完全一致，只是考虑的角度不同

代码

class Solution {
    
    
    int m, n;
    //cache记忆化，表示i，j能走的最长的递增路径
    int cache[][], matrix[][];
    int dx[] = new int[]{
    
    0, 1, 0, -1};
    int dy[] = new int[]{
    
    1, 0, -1, 0};
    public int longestIncreasingPath(int[][] _matrix) {
    
    
        matrix = _matrix;
        m = matrix.length;
        n = matrix[0].length;
        cache = new int[m][n];
        int ans = 1;
        //枚举起点位置
        for (int i = 0; i < m; i ++ ) {
    
    
            for (int j = 0; j < n; j ++ ) {
    
    
                ans = Math.max(ans, dfs(i, j));
            }
        }
        return ans;
    }
    public int dfs(int i, int j) {
    
    
        //如果缓存有就直接返回
        if (cache[i][j] != 0) return cache[i][j]; 
        //设置每次的步长为1
        int step = 1;
        //开始四个方向探索以i，j为起点的最长递增路径长度
        for (int d = 0; d < 4; d ++ ) {
    
    
            int ni = i + dx[d];
            int nj = j + dy[d];
            if (ni < 0 || ni >= m || nj < 0 || nj >= n) continue;
            //如果新的位置的值比原来的大，才走过去
            if (matrix[ni][nj] > matrix[i][j]) {
    
    
                //也要保证取max，因为这条路径最终不一定比原来的路径大
                step = Math.max(step, 1 + dfs(ni, nj));
            }
        }
        //将当前的路径记忆化
         cache[i][j] = step;
         return step;
    }
}