329. Longest Increasing Path in a Matrix

Description

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:

Input: nums =
[
[9,9,4],
[6,6,8],
[2,1,1]
]
Output: 4
Explanation: The longest increasing path is [1, 2, 6, 9].
Example 2:

Input: nums =
[
[3,4,5],
[3,2,6],
[2,2,1]
]
Output: 4
Explanation: The longest increasing path is [3, 4, 5, 6]. Moving diagonally is not allowed.
Problem URL

---

Solution

给一个二维数组，找到其中最长的递增路径的长度。

Using DFS to find the longest path’s length, then using another two dimensional array which contains the length of each cell’s longest path. Because they may be reused. Because we are looking for a longest increasing, using this condition we won’t need a visited array anymore.

Code

class Solution {
    private int[][] dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    public int longestIncreasingPath(int[][] matrix) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0){
            return 0;
        }
        int m = matrix.length;
        int n = matrix[0].length;
        int[][] cache = new int[m][n];
        int res = 1;
        for (int i = 0; i < m; i++){
            for (int j = 0; j < n; j++){
                int len = dfs(matrix, cache, i, j);
                res = Math.max(res, len);
            }
        }
        return res;
    }
    
    private int dfs(int[][] matrix, int[][] cache, int i, int j){
        if (cache[i][j] != 0){
            return cache[i][j];
        }
        int max = 1;
        int m = matrix.length;
        int n = matrix[0].length;
        for (int[] dir : dirs){
            int x = i + dir[0];
            int y = j + dir[1];
            if (x < 0 || x >= m || y < 0 || y >= n || matrix[x][y] <= matrix[i][j]){
                continue;
            }
            int len = dfs(matrix, cache, x, y) + 1;
            max = Math.max(max, len);
        }
        cache[i][j] = max;
        return max;
    }
}

Time Complexity: O(mn)
Space Complexity: O(mn)

---

Review