[LeetCode 329] Longest Increasing Path in a Matrix

最新推荐文章于 2025-02-03 15:37:10 发布

原创最新推荐文章于 2025-02-03 15:37:10 发布 · 2.1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #DFS

Leetcode 同时被 2 个专栏收录

287 篇文章

订阅专栏

Java

106 篇文章

订阅专栏

本文介绍了一个寻找二维矩阵中最长递增路径的算法解决方案。通过深度优先搜索(DFS)遍历所有节点，并使用缓存数组避免重复访问，显著减少了不必要的运算。时间复杂度为O(nm)，其中n和m分别是矩阵的行数和列数。

Given an integer matrix, find the length of the longest increasing path.

From each cell, you can either move to four directions: left, right, up or down. You may NOT move diagonally or move outside of the boundary (i.e. wrap-around is not allowed).

Example 1:

nums = [
  [9,9,4],
  [6,6,8],
  [2,1,1]
]

Return 4
The longest increasing path is [1, 2, 6, 9].

Example 2:

nums = [
  [3,4,5],
  [3,2,6],
  [2,2,1]
]

Return 4
The longest increasing path is [3, 4, 5, 6]. Moving diagonally is not allowed.

Solution:

DFS to go through all nodes and use another array to cache all the visited node, incase we revisit again. reduce alot of unnecessnary operations. Time complixity is O(nm)

public int longestIncreasingPath(int[][] matrix) {
        if(matrix.length<=0 || matrix[0].length <=0) return 0;
        int max=0, n = matrix.length, m = matrix[0].length;
        int [][] cache = new int[n][m];
        for(int i=0;i<matrix.length;i++){
            for(int j=0;j<matrix[0].length;j++) {
                max = Math.max(max, maxLen(matrix, Integer.MIN_VALUE, i, j, cache));
            }
        }
        return max;
    }
    public int maxLen(int[][] matrix, int min, int r, int c, int[][] cache) {
        if(r<0 || c<0 || r>=matrix.length || c>= matrix[0].length) {
            return 0;
        }
        if(matrix[r][c] <= min) {
            return 0;
        }
        if(cache[r][c] != 0) {
            return cache[r][c];
        }
        min = matrix[r][c];
        int up = maxLen(matrix, min, r-1, c, cache) + 1;
        int left = maxLen(matrix, min, r, c-1, cache) + 1;
        int right = maxLen(matrix, min, r, c+1, cache) + 1;
        int down = maxLen(matrix, min, r+1, c, cache) + 1;
        cache[r][c] = Math.max(up, Math.max(left, Math.max(right,down)));
        return cache[r][c];
    }