LeetCode-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.

Analysis:

We can use DFS + memrization.

At curret point (i,j), we detect all for directions, find the LIP of the 4 neighbor nodes and select the longest one to construct LIP of (i,j). Once we finish, we can record the LIP len of (i,j), so if this len is queried later, we do not need to find it again.

Some notes:

1. We do not need to record points on current search path, because it is increasing path, no furture point will be one of the points on path.

2. We do not need to record the points on the LIP of (i,j), intead, we just need to record the length.

3. We do not need to worry that a neighbor point's LIP will overlap with the points on current search path, because it is increasing path.

Solution:

public class Solution {
    int[] xMove = new int[]{1,0,-1,0};
    int[] yMove = new int[]{0,1,0,-1};
    
    public int longestIncreasingPath(int[][] matrix) {
        if (matrix.length == 0 || matrix[0].length == 0)
            return 0;

        int[][] lipLen = new int[matrix.length][matrix[0].length];
        int maxLen = 0;
        for (int i = 0; i < matrix.length; i++)
            for (int j = 0; j < matrix[0].length; j++) {
                int len = findLIPRecur(matrix, lipLen, i, j);
                if (maxLen < len)
                    maxLen = len;
            }

        return maxLen;
    }

    public int findLIPRecur(int[][] matrix, int[][] lipLen, int x, int y) {
        // if current point is already addressed
        if (lipLen[x][y] != 0)
            return lipLen[x][y];

        int maxLen = 0;
        for (int i = 0; i < xMove.length; i++) {
            int nextX = x + xMove[i];
            int nextY = y + yMove[i];
            if (isFeasible(matrix, nextX, nextY) && matrix[nextX][nextY] > matrix[x][y]) {
                int len = findLIPRecur(matrix, lipLen, nextX, nextY);
                if (maxLen < len) {
                    maxLen = len;
                }
            }
        }

        // Record LIP len of current point
        lipLen[x][y] = maxLen + 1;
        return maxLen + 1;
    }
    
    public boolean isFeasible(int[][] matrix, int x, int y) {
        return (x < matrix.length && x >= 0) && (y < matrix[0].length && y >= 0);
    }


}