329. 矩阵中的最长递增路径

给定一个整数矩阵,找出最长递增路径的长度。

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

示例 1:

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

dfs+记忆矩阵(保存以该点位起点的最长路径) 44ms

class Solution {
public:
        int direct[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
        int dfs(vector> &matrix, vector> &memo, int x, int y){
        
        if(memo[x][y]!=-1) return memo[x][y];
        int ans = 1;
        for(int k=0;k<4;k++)
        {
                int tx = x+direct[k][0], ty = y+direct[k][1];
                if(tx=0 && ty>=0 && tymatrix[tx][ty])
                    ans = max(ans, 1+dfs(matrix, memo, tx, ty));  
        }    
    
        return memo[x][y]=ans;
    }
    int longestIncreasingPath(vector>& matrix) {
        
        // 方法一:给定初始节点,dfs搜索
        int m = matrix.size(); if(m==0) return 0;
        int n = matrix[0].size(); if(n==0) return 0;
        vector> memo(m, vector(n, -1));
        int ans = 1;
        for(int i=0; i

dfs+记忆矩阵(保存到达该点前走过的的最长路径) 164ms

class Solution {
public:
    int max_len=0;
    int direct[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
    void dfs(int i,int j,int len,vector>& matrix,vector> &v)
    {
        max_len=max(max_len,len);
        for(int k=0;k<4;k++)
        {
            int nexti,nextj;
            nexti=i+direct[k][0];
            nextj=j+direct[k][1];
            if(0<=nexti&&nextimatrix[i][j])
            {
                if(v[nexti][nextj]>=len) continue;
                v[nexti][nextj]=len;
                dfs(nexti,nextj,len+1,matrix,v);
            }
        }
    }
    int longestIncreasingPath(vector>& matrix) {
        if(matrix.size()==0) return 0;
        vector>v(matrix.size(),vector(matrix[0].size(),0));
        for(int i=0;i=1) continue;
                dfs(i,j,1,matrix,v);
            }
        return max_len;
    }
};

你可能感兴趣的:(领扣)