[LeetCode 329] Longest Increasing Path in a Matrix

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];
    }