每日OJ题_牛客_NC138矩阵最长递增路径_记忆化搜索_C++_Java

目录

牛客_NC138矩阵最长递增路径_记忆化搜索

题目解析

C++代码

Java代码

---

牛客_NC138矩阵最长递增路径_记忆化搜索

矩阵最长递增路径_牛客题霸_牛客网

描述：

给定一个 n 行 m 列矩阵 matrix ，矩阵内所有数均为非负整数。 你需要在矩阵中找到一条最长路径，使这条路径上的元素是递增的。并输出这条最长路径的长度。

这个路径必须满足以下条件：

1. 对于每个单元格，你可以往上，下，左，右四个方向移动。 你不能在对角线方向上移动或移动到边界外。

2. 你不能走重复的单元格。即每个格子最多只能走一次。

数据范围：1≤n,m≤1000，0≤matrix[i][j]≤1000

进阶：空间复杂度 O(nm) ，时间复杂度 O(nm)

例如：当输入为[[1,2,3],[4,5,6],[7,8,9]]时，对应的输出为5，

其中的一条最长递增路径如下图所示：

---

题目解析

递归改记忆化搜索即可。

• 矩阵内是非负数，求最长的递增路径的长度。
• 移动方向可以是上下左右，不能超出边界，这将是递归的判定条件。
• 同一条路径不能有重复的单元格，需要有记忆。

C++代码

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 递增路径的最大长度
     * @param matrix int整型vector<vector<>> 描述矩阵的每个数
     * @return int整型
     */

    int m = 0, n = 0;
    int dx[4] = {0, 0, -1, 1};
    int dy[4] = {1, -1, 0, 0};
    int memo[1007][1007];
    int solve(vector<vector<int> >& matrix) { // dfs?
        memset(memo, -1, sizeof(memo));
        m = matrix.size(), n = matrix[0].size();
        // dfs(matrix, 0, 0);
        int ret = 0;
        for(int i = 0; i < m; ++i) // 可以以任何位置为起点
        {
            for(int j = 0; j < n; ++j)
            {
                ret = max(ret, dfs(matrix, i, j));
            }
        }
        return ret;
    }

    int dfs(vector<vector<int>>& arr, int sr, int sc)
    {
        if(memo[sr][sc] != -1)
            return memo[sr][sc];
        int len = 1;
        // cout << sr << " " << sc << " " << arr[sr][sc] << " " << dfsLevel << endl;
        for(int i = 0; i < 4; ++i)
        {
            int x = sr + dx[i], y = sc + dy[i];
            if(x >= 0 && x < m && y >= 0 && y < n && arr[x][y] > arr[sr][sc]) // 严格递增
            {
                len = max(len, 1 + dfs(arr, x, y));
            }
        }
        memo[sr][sc] = len;
        return len;
    }
};

Java代码

import java.util.*;
public class Solution
{
    int m, n;
    int[] dx = {0, 0, 1, -1};
    int[] dy = {1, -1, 0, 0};
    int[][] memo = new int[1010][1010];
    public int dfs(int[][] matrix, int i, int j)
    {
        if(memo[i][j] != -1)
            return memo[i][j];
        int len = 1;
        for(int k = 0; k < 4; k++)
        {
            int x = i + dx[k], y = j + dy[k];
            if(x >= 0 && x < m && y >= 0 && y < n && matrix[x][y] > matrix[i][j])
            {
                len = Math.max(len, 1 + dfs(matrix, x, y));
            }
        }
        memo[i][j] = len;
        return len;
    }
    public int solve (int[][] matrix) 
    {
        m = matrix.length; n = matrix[0].length;
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                memo[i][j] = -1;
            }
        }
        int ret = 1;
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                ret = Math.max(ret, dfs(matrix, i, j));
            }
        }
        return ret;
    }
}