（LeetCode 329）矩阵中的最长递增路径 [简单DP & 公式：dp[x][y] = dp[xx][yy] + 1]

329. 矩阵中的最长递增路径
给定一个整数矩阵，找出最长递增路径的长度。

对于每个单元格，你可以往上，下，左，右四个方向移动。 你不能在对角线方向上移动或移动到边界外（即不允许环绕）。

示例 1:

输入: nums =
[
[9,9,4],
[6,6,8],
[2,1,1]
]
输出: 4
解释: 最长递增路径为 [1, 2, 6, 9]。
示例 2:

输入: nums =
[
[3,4,5],
[3,2,6],
[2,2,1]
]
输出: 4
解释: 最长递增路径是 [3, 4, 5, 6]。注意不允许在对角线方向上移动。

分析：
本题和“滑雪”是同一题，为了练手又写了一遍：https://blog.csdn.net/STILLxjy/article/details/52097384

dp[x][y] 表示从(x,y)向四周出发可以达到的最长下降路径长度。
dp公式： dp[x][y] = max(dp[x][y]，dp[xx][yy] + 1),其中 （xx,yy）是（x,y）四周的位置坐标。

注意：
（1）如何申请二维vector空间，并进行初始化： vector<vector> dp(m,vector(n,0));

（2） 若去掉dfs(vector<vector>& matrix, vector<vector>& dp,int x, int y,int m, int n,int& max_ans)中matrix 前的 & 会导致超内存， 因为每次都会重新开辟空间且赋值。

AC代码：

class Solution {
public:
    int dy[4] = {0,1,0,-1};
    int dx[4] = {-1,0,1,0};

    bool check(int x,int y,int m,int n)
    {
        return x>=0 && x<m && y>=0 && y<n;
    }
    
    int dfs(vector<vector<int>>& matrix, vector<vector<int>>& dp,int x, int y,int m, int n,int& max_ans)
    {
        if(dp[x][y] > 0) return dp[x][y];
        dp[x][y] = 1;
        for(int k=0;k<4;k++)
        {
            int xx = x + dx[k];
            int yy = y + dy[k];
            if(check(xx,yy,m,n) && matrix[x][y] > matrix[xx][yy])
                dp[x][y] = max(dp[x][y], dfs(matrix,dp,xx,yy,m,n,max_ans)+1);
            max_ans = max(max_ans,dp[x][y]);
        }
        return dp[x][y];
    }
    
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        if(matrix.empty()) return 0;
        int m = matrix.size();
        int n = matrix[0].size();
        vector<vector<int>> dp(m,vector<int>(n,0));
        int max_ans = 1;
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(dp[i][j] == 0)
                {
                    dfs(matrix,dp,i,j,m,n,max_ans);
                }
            }
        }
        return max_ans;
    }
};