Leetcode--329. 矩阵中的最长递增路径_leetcode 329 时间复杂度-优快云博客

本文链接：https://blog.youkuaiyun.com/hx1043116928/article/details/109730687

本文介绍如何使用深度优先搜索算法解决给定整数矩阵中寻找最长递增路径的问题，并通过记忆化技术提高效率。通过实例演示和代码实现，探讨了在矩阵中向上、下、左、右移动寻找递增序列的策略。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

给定一个整数矩阵，找出最长递增路径的长度。

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

示例 1:

输入: nums =
[
[9,9,4],
[6,6,8],
[2,1,1]
]
输出: 4
解释: 最长递增路径为 [1, 2, 6, 9]。
示例 2:

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

思路：可以看作有向图，在点(i,j)相邻的四个点中，从低的值到高的值有一条边

通过深度优先遍历可以解决，但是时间复杂度极高，因此想办法将找过的记录存下来，记忆化搜索。

dp[i][j]!=0时,表示被搜索过

class Solution {
    private int[][] dir = {{0,1},{0,-1},{1,0},{-1,0}};
    public int dfs(int dp[][],int matrix[][],int i,int j){
        if(dp[i][j]!=0){
            return dp[i][j];
        }
        dp[i][j]++;
        for(int[] ints : dir){
            int row = i+ints[0];
            int column = j+ints[1];
            if(row>=matrix.length||row<0||column<0||column>=matrix[0].length){
                continue;
            }
            if(matrix[i][j]<matrix[row][column]){
                dp[i][j] = Math.max(dp[i][j],dfs(dp,matrix,row,column)+1);
            }
        }
        return dp[i][j];

    }
    public int longestIncreasingPath(int[][] matrix) {
        if(matrix.length==0||matrix[0].length==0){
            return 0;
        }
        int dp[][]  = new int[matrix.length][matrix[0].length];
        int max = -2147483647>>1;
        for(int i=0;i<matrix.length;i++){
            for(int j=0;j<matrix[0].length;j++){
                max = Math.max(max,dfs(dp,matrix,i,j));
            }
        }
        return max;
    }
}