当前位置：首页 > news >正文

LeetCode 0329. 矩阵中的最长递增路径

news 来源：原创 2024/5/20 2:19:01

【LetMeFly】329.矩阵中的最长递增路径：从大到小处理的动态规划

力扣题目链接：https://leetcode.cn/problems/longest-increasing-path-in-a-matrix/

给定一个 m x n 整数矩阵 matrix ，找出其中 最长递增路径 的长度。

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

示例 1：

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

示例 2：

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

示例 3：

输入：matrix = [[1]]
输出：1

提示：

m == matrix.length
n == matrix[i].length
1 <= m, n <= 200
0 <= matrix[i][j] <= 2³¹ - 1

方法一：从大到小处理的动态规划

因为路径必须是严格递增的，因此如果从地图中最大的值开始，“最长递增路径”就是“1”（因为没有比它更大的了）

处理完最大的数，我们就可以处理“第二大”的数了。第二大的数四周如果有第一大的数，那么从这个第二大的数开始出发，“最长递增路径”为“2”

接着我们可以处理第三大的数、第四大的数、……

总之，只需要将原始地图中的元素按从大到小的顺序排个序（注意排序过程中，元素在地图中的原始位置信息不要丢失），就能从大到小开始遍历。遍历到一个数时，看这个数的四周有没有比它大的数，如果有，从这个数出发的“最长递增路径”就可以是“从它旁边比它大的数出发的最长路径 + 1”

整个过程中，不断更新“从某个点出发的最长递增路径”的最大值即为答案。

时间复杂度 $O (mn)$
空间复杂度 $n\times \log (m n))$

AC代码

C++

struct MyNode {
    int x, y;
    int val;
};

bool cmp(const MyNode& a, const MyNode& b) {
    return a.val > b.val;
}

const int directions[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

class Solution {
public:
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        int n = matrix.size(), m = matrix[0].size();
        vector<MyNode> nodes;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                nodes.push_back({i, j, matrix[i][j]});
            }
        }
        sort(nodes.begin(), nodes.end(), cmp);
        vector<vector<int>> dp(n, vector<int>(m, 1));
        int ans = 1;
        for (MyNode thisNode : nodes) {
            int x = thisNode.x, y = thisNode.y;
            int val = thisNode.val;
            for (int d = 0; d < 4; d++) {
                int tx = x + directions[d][0];
                int ty = y + directions[d][1];
                if (tx >= 0 && tx < n && ty >= 0 && ty < m) {
                    if (matrix[tx][ty] > val) {
                        dp[x][y] = max(dp[x][y], dp[tx][ty] + 1);
                    }
                }
            }
            ans = max(ans, dp[x][y]);
        }
        return ans;
    }
};