Leetcode 329 - Longest Increasing Path in a Matrix（dfs or dp）

最新推荐文章于 2025-07-29 14:24:32 发布

原创最新推荐文章于 2025-07-29 14:24:32 发布 · 360 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

leetcode 同时被 3 个专栏收录

157 篇文章

订阅专栏

66 篇文章

订阅专栏

搜索

18 篇文章

订阅专栏

本文探讨了在给定矩形中寻找最长增长路径的方法，提供了两种算法：一是通过枚举起点并使用深度优先搜索；二是采用排序加动态规划的方式。文章详细介绍了这两种算法的具体实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意

给定一个矩形，求矩形中的最长增长路径。只能沿上下左右四个方向。

思路

算法1

枚举起点，然后记搜。

算法2

排序 + dp

创建一个节点node，包含矩阵中每个点的横坐标，纵坐标，值。

然后按照值增长的顺序对node进行排序。然后问题转化成了一个变相的LIS。

按照条件进行转移即可。

代码

algorithm 1

int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};

class Solution {
public:
    int dfs(int x, int y, vector<vector<int>>& a, vector<vector<int>>& d) {
        if (d[x][y] != 0) return d[x][y];
        int m = a.size(), n = a[0].size();
        d[x][y] = 1;
        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i], ny = y + dy[i];
            if (nx >= 0 && nx < m && ny >= 0 && ny < n && a[x][y] > a[nx][ny]) {
                d[x][y] = max(d[x][y], 1 + dfs(nx, ny, a, d));
            }
        }
        return d[x][y];
    }

    int longestIncreasingPath(vector<vector<int>>& a) {
        int m = a.size();
        if (m) {
            int n = a[0].size(), ans = 1;
            vector<vector<int>> d(m, vector<int>(n, 0));
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    ans = max(ans, dfs(i, j, a, d));
                }
            }
            return ans;
        }
        return 0;
    }
};

algorithm 2

struct node {
    int x, y, val;
    node(int a, int b, int c) : x(a), y(b), val(c) {
    }
};

bool cmp(node& a, node& b) {
    return a.val < b.val;
}
class Solution {
public:
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        vector<node> a;
        int m = matrix.size();
        if (m) {
            int n = matrix[0].size();
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    a.push_back(node(i, j, matrix[i][j]));
                }
            }
            sort(a.begin(), a.end(), cmp);
            vector<int> d(m * n, 1);
            int ans = 1;
            for (int i = 0; i < m * n; i++) {
                for (int j = 0; j < i; j++) {
                    if (a[i].val > a[j].val && abs(a[i].x - a[j].x) + abs(a[i].y - a[j].y) == 1) {
                        d[i] = max(d[i], d[j] + 1);
                    }
                }
                ans = max(ans, d[i]);
            }
            return ans;
        }
        return 0;
    }
};