Leetcode no. 329

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.

public class Solution {
    public int longestIncreasingPath(int[][] matrix) {
        if (matrix.length==0 || matrix[0].length==0) return 0;
        int[][] results= new int[matrix.length][matrix[0].length];
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                results[i][j]=-1;
            }
        }
        int longest=0;
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                if (results[i][j]==-1) {
                    results[i][j] = longestIncreasingPath(matrix, results, i, j);
                    longest= longest>=results[i][j] ? longest : results[i][j];
                }
            }
        }
        return longest;
    }
    private int longestIncreasingPath(int[][] matrix, int[][] res,int row, int col){
        int longest=0;
        if (res[row][col]!=-1) return res[row][col];
        if (row-1>=0 && matrix[row-1][col]>matrix[row][col]){
            int lower= longestIncreasingPath(matrix, res, row-1, col);
            longest= longest>=lower ? longest : lower;
        }
        if (row+1<matrix.length && matrix[row+1][col]>matrix[row][col]){
            int upper= longestIncreasingPath(matrix, res, row+1, col);
            longest= longest>=upper ? longest : upper;
        }
        if (col-1>=0 && matrix[row][col-1]>matrix[row][col]){
            int left= longestIncreasingPath(matrix, res, row, col-1);
            longest= longest>=left ? longest : left;
        }
        if (col+1<matrix[0].length && matrix[row][col+1]>matrix[row][col]){
            int right= longestIncreasingPath(matrix, res, row, col+1);
            longest= longest>=right ? longest : right;
        }
        res[row][col]=longest+1;
        return longest+1;
    }
}