leetcode题：329. 矩阵中的最长递增路径（困难）

一、题目描述：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]。注意不允许在对角线方向上移动。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-increasing-path-in-a-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解题思路

方法一、暴力深度优先搜索递归，对每个点上下左右点，如果符合递增属性(不需要判断是否visited过，因为是递增的不会重复遍历），进行递归，查找递增子序。这种方法会超时

方法二、由于在方法一的基础上，使用一个map dp记录每个节点的最长递增子序列个数。当递归到当前节点的时候，如果当前节点已经存在dp里则直接返回dp里存的值，不要重复递归。

方法三、动态规划，大神的思路：https://leetcode-cn.com/problems/longest-increasing-path-in-a-matrix/solution/ju-zhen-zhong-de-zui-chang-di-zeng-lu-jing-by-leet/

三、代码

class Solution {
public:
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        if(matrix.size() == 0)
            return 0;
        map<pair<int,int>,int> dp;
        //vector<vector<int>> visited(matrix.size(),vector<int>(matrix[0].size(),0));
        int max_len = 1;
        for(int i = 0; i < matrix.size();i++)
        {
            for(int j = 0; j < matrix[i].size(); j ++)
            {
                //visited[i][j] = 1;
                int len_t = 0;
                pair<int,int> p(i,j);
                if(dp.count(p) > 0)
                {
                    len_t = dp[p];
                }
                else
                {
                    len_t = getPath(matrix,i,j,dp);
                }
                //visited[i][j] = 0;
                max_len = max(max_len,len_t);
            }
        }
        return max_len;
    }
    int getPath(vector<vector<int>>& matrix,int i,int j,map<pair<int,int>,int> & dp)
    {
        int len_r = 0;
        if(i-1 >= 0 && matrix[i][j] < matrix[i-1][j])
        {
            int len_t = 0;
            pair<int,int> p(i-1,j);
            if(dp.count(p) > 0)
            {
                len_t = dp[p];
            }
            else
            {
               
                len_t = getPath(matrix,i-1,j,dp);
                
                dp[p] = len_t;
            }
            len_r = max(len_t,len_r);
        }
        if(j-1 >= 0 && matrix[i][j] < matrix[i][j-1])
        {
            int len_t = 0;
            pair<int,int> p(i,j-1);
            if(dp.count(p) > 0)
            {
                len_t = dp[p];
            }
            else{
        
            len_t = getPath(matrix,i,j-1,dp);
            
                dp[p] = len_t;
            }
            len_r = max(len_t,len_r);
        }
        if(i+1 <matrix.size() && matrix[i][j] < matrix[i+1][j])
        {
            int len_t = 0;
            pair<int,int> p(i+1,j);
            if(dp.count(p) > 0)
            {
                len_t = dp[p];
            }
            else{
            
            len_t = getPath(matrix,i+1,j,dp);
            
                dp[p] = len_t;
            }
            len_r = max(len_t,len_r);
        }
        if(j+1 < matrix[i].size() && matrix[i][j] < matrix[i][j+1])
        {
            int len_t = 0;
            pair<int,int> p(i,j+1);
            if(dp.count(p) > 0)
            {
                len_t =dp[p];
            }
            else{
           
            len_t = getPath(matrix,i,j+1,dp);
                dp[p] = len_t;
            }
            len_r = max(len_t,len_r);
        }
        return len_r + 1;
        
    }
};