leetcode@ [329] Longest Increasing Path in a Matrix (DFS + 记忆化搜索)

https://leetcode.com/problems/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:
    bool checkRange(vector<vector<int> >& matrix, int x, int y) {
        int n = matrix.size(), m = matrix[].size();
        if(x <  || y <  || x >= n || y >= m)  return false;
        return true;
    }

    int dfs(vector<vector<int> >& matrix, vector<vector<int> >& dp, vector<vector<bool> >& vis, vector<vector<int> >& dir, int x, int y) {
        if(dp[x][y])  return dp[x][y];

        int MAX = -;
        for(int i=; i<dir.size(); ++i) {
            int nx = x + dir[i][], ny = y + dir[i][];
            if(checkRange(matrix, nx, ny) && !vis[nx][ny] && matrix[nx][ny] > matrix[x][y]) {
                vis[nx][ny] = true;
                MAX = max(MAX, dfs(matrix, dp, vis, dir, nx, ny) + );
                vis[nx][ny] = false;
            }
        }

        if(MAX == -) return ;
        dp[x][y] = MAX;
        return dp[x][y];
    }

    int longestIncreasingPath(vector<vector<int>>& matrix) {
        int n = matrix.size();
        if(n == )  return ;

        int m = matrix[].size();
        vector<vector<int> > dp(n, vector<int>(m, ));
        vector<vector<bool> > vis(n, vector<bool>(m, false));
        vector<vector<int> > dir();
        dir[].push_back(-);  dir[].push_back();
        dir[].push_back();  dir[].push_back();
        dir[].push_back();  dir[].push_back();
        dir[].push_back();  dir[].push_back(-);

        int res = -;
        for(int i=; i<n; ++i) {
            for(int j=; j<m; ++j) {
                vis[i][j] = true;
                dp[i][j] = dfs(matrix, dp, vis, dir, i, j);
                res = max(res, dp[i][j]);
                vis[i][j] = false;
            }
        }

        return res;
    }
};