最长递增路径两种解法：leetcode-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]。注意不允许在对角线方向上移动。

一开始写了个朴素dfs，数据比较大时指数增长会超时，过了100多条数据，剩下3条过不了。

---

可以对比以下两种方法：
第二种AC的方法是通过第一种DFS改的，可以通过对比来学习

---

解一。DFS（超时）

class Solution {
    int dfs(vector<vector<int>>& matrix,int x,int y,int cnt,int max0) {
        max0=max(++cnt,max0);

        if (y==matrix[0].size()&& x==matrix.size())    return 0;
        
        if (x + 1 < matrix.size() && matrix[x][y]<matrix[x+1][y]) {
            
            max0=max(max0,dfs(matrix, x + 1, y,cnt, max0));
            
        }
        
        if (y + 1 < matrix[0].size()&& matrix[x][y]<matrix[x][y+1]) {
            max0=max(max0,dfs(matrix, x, y + 1, cnt, max0));

        }
       
        if (y - 1 >=0 && matrix[x][y]<matrix[x][y-1]) {
            max0=max(max0,dfs(matrix, x, y - 1, cnt, max0));

        }
        
        if (x - 1 >=0&& matrix[x][y]<matrix[x-1][y]) {
            max0=max(max0,dfs(matrix, x - 1, y, cnt, max0));
        }       
        return max0;
     }

    int dfs0(vector<vector<int>>& matrix,int max0) {
        int cnt = 0;
        for (int i = 0; i <matrix.size() ;i++) {
            cnt=0;
            for (int j = 0; j <matrix[0].size() ;j++) {
                max0=max(max0,dfs(matrix, i, j, cnt, max0));
                cnt=0;
            }
        }
        return max0;
    }

public:
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        int max=0;
        max=dfs0(matrix,max);
        return max;
    }
};

然后学了个记忆化dfs，可以通过。

解2 记忆化搜索：

class Solution {
    int dfs(vector<vector<int>>& demo,vector<vector<int>>& matrix,int x,int y,int cnt,int max0) {
        //固定
        //已经记录最优，则获取
        if(demo[x][y]!=0)   return demo[x][y];

        //一般都要
        //初始条件
        demo[x][y]=1;
        
        // 逻辑不变
        if (y==matrix[0].size()&& x==matrix.size())    return 0;
        
        if (x + 1 < matrix.size() && matrix[x][y]<matrix[x+1][y]) {
            //dfs时,修改demo
            demo[x][y]=max(demo[x][y],dfs(demo,matrix, x + 1, y,cnt, max0)+1);
            
        }
        
        if (y + 1 < matrix[0].size()&& matrix[x][y]<matrix[x][y+1]) {
            //dfs时,修改demo
            demo[x][y]=max(demo[x][y],dfs(demo,matrix, x, y + 1, cnt, max0)+1);
        }
       
        if (y - 1 >=0 && matrix[x][y]<matrix[x][y-1]) {
            //dfs时,修改demo
            demo[x][y]=max(demo[x][y],dfs(demo,matrix, x, y - 1, cnt, max0)+1);
        }
        
        if (x - 1 >=0&& matrix[x][y]<matrix[x-1][y]) {
            //dfs时,修改demo
            demo[x][y]=max(demo[x][y],dfs(demo,matrix, x - 1, y, cnt, max0)+1);
        }     

        //固定  
        //返回demo
        return demo[x][y];
     }

    int dfs0(vector<vector<int>>& matrix,int max0) {
        int cnt = 0;
        int res=0;
        auto demo = vector< vector<int> > (matrix.size(), vector <int> (matrix[0].size()));
        for (int i = 0; i <matrix.size() ;i++) {
            cnt=0;
            for (int j = 0; j <matrix[0].size() ;j++) {
                res=max(res,dfs(demo,matrix, i, j, cnt, max0));
                cnt=0;
            }
        }
        return res;
    }

public:
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        if(matrix.size()==0){
            return 0;
        }
        int max=0;
        max=dfs0(matrix,max);
        return max;
    }
};