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.

第一种方法，递归。很明显，时间超时，通不过。

class Solution {
    public int longestIncreasingPath(int[][] matrix) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) return 0;
        int max = 0;
        boolean[][] visited = new boolean[matrix.length][matrix[0].length];
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                max = Math.max(max, helper(matrix, visited, i, j));
            }
        }
        return max;
    }

    public int helper(int[][] A, boolean[][] visited, int i, int j) {
        visited[i][j] = true;
        int[][] neighbors = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}};
        int max = 0;
        for (int[] neighbor : neighbors) {
            int row = i + neighbor[0];
            int col = j + neighbor[1];
            if (row >= 0 && row < A.length && col >= 0 && col < A[0].length && !visited[row][col] && A[row][col] > A[i][j]) {
                max = Math.max(max, helper(A, visited, row, col));
            }
        }
        visited[i][j] = false;
        return max + 1;
    }
}

第二种方法类似第一种方法，但是我们不会每次都对同一个位置重复计算。对于一个点来讲，它的最长路径是由它周围的点决定的，你可能会认为，它周围的点也是由当前点决定的，这样就会陷入一个死循环的怪圈。其实并没有，因为我们这里有一个条件是路径上的值是递增的，所以我们一定能够找到一个点，它不比周围的值大，这样的话，整个问题就可以解决了。

public class Solution {
    public int longestIncreasingPath(int[][] A) {
        int res = 0;
        if (A == null || A.length == 0 || A[0].length == 0) {
            return res;
        }
        int[][] store = new int[A.length][A[0].length];
        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < A[0].length; j++) {
                if (store[i][j] == 0) {
                    res = Math.max(res, dfs(A, store, i, j));
                }
            }
        }
        return res;
    }

    private int dfs(int[][] A, int[][] store, int i, int j) {
        if (store[i][j] != 0) return store[i][j];
        int max = 0;
        int[][] neighbors = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}};
        for (int[] neighbor : neighbors) {
            int row = i + neighbor[0];
            int col = j + neighbor[1];
            if (row >= 0 && row < A.length && col >= 0 && col < A[0].length && A[row][col] > A[i][j]) {
                max = Math.max(max, dfs(A, store, row, col));
            }
        }
        store[i][j] = max + 1;
        return store[i][j];
    }
}