每日一题之拉低通过率 leetcode 329

最新推荐文章于 2023-03-29 18:43:37 发布

WatchLessMobile

最新推荐文章于 2023-03-29 18:43:37 发布

阅读量210

点赞数 1

文章标签： leetcode 算法

本文链接：https://blog.csdn.net/weixin_45748610/article/details/108791818

版权

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

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

示例 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]。注意不允许在对角线方向上移动。

思路：闫氏DP分析法
dp[i][j]：以matrix[i][j]结尾时的最长递增路径集合
属性：MAX

集合划分：

dp[i][j]前面有序列
dp[i][j]作为开头

现附上错误代码
发现当开头是最小值时才准确

class Solution {
public:
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        int row = matrix.size(), column = matrix[0].size();
        int dp[row][column];
        int MAX = 0, i, j;
        for (int i = 0; i < row; i ++) {
            for (int j = 0; j < column; j ++)
                dp[i][j] = 0;
        }
        for (i = 0; i < row; i ++) {
            for (j = 0; j < column; j ++) {
                
                int up = i - 1, down = i + 1, left = j - 1, right = j + 1, node = dp[i][j], t = matrix[i][j];
                if (up >= 0 && matrix[up][j] < t)    node = dp[up][j];
                if (down < row && matrix[down][j] < t)    node = max (node, dp[down][j]);
                if (left >= 0 && matrix[i][left] < t)     node = max (node, dp[i][left]);
                if (right < column && matrix[i][right] < t)     node = max (node, dp[i][right]);
                node = max (node + 1, 1);
                dp[i][j] = node;
                if (MAX < node) MAX = node;
            }          
        }
        return MAX;
    }
};
//当开头是最小值的时候才准确
//换个思路：先找到最小值再开始遍历

先从最小节点开始？思路转到深度优先搜索那里去了。可是想用动态规划做。
于是只好找了评论区一个大佬的代码

class Point {
public:
    int x, y, v;
    Point(int ix, int iy, int iv) {
        x = ix;
        y = iy;
        v = iv;
    }
};

class Solution {
public:
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        if (matrix.size() == 0)
            return 0;
        const int rows = matrix.size();
        const int cols = matrix[0].size();
        vector<vector<int>> dp(rows, vector<int>(cols, 1));
        vector<Point> vp;
        vp.reserve(rows * cols);
        for (int i = 0; i < rows; i++)
            for (int j = 0; j < cols; j++) {
                vp.push_back(Point(i, j, matrix[i][j]));
            }
        // 对坐标排序
        sort(vp.begin(), vp.end(), [](const Point &lhs, const Point &rhs){
            return lhs.v < rhs.v;
        });
        int ret = 1;
        for (const auto &p : vp) {
            auto x = p.x;
            auto y = p.y;
            auto v = p.v;
            // 寻找附近比当前矮的点的最高DP值
            if (x > 0 && matrix[x - 1][y] < v && dp[x - 1][y] + 1 > dp[x][y])
                dp[x][y] = dp[x - 1][y] + 1;
            if (x < rows - 1 && matrix[x + 1][y] < v && dp[x + 1][y] + 1 > dp[x][y])
                dp[x][y] = dp[x + 1][y] + 1;
            if (y > 0 && matrix[x][y - 1] < v && dp[x][y - 1] + 1 > dp[x][y])
                dp[x][y] = dp[x][y - 1] + 1;
            if (y < cols - 1 && matrix[x][y + 1] < v && dp[x][y + 1] + 1 > dp[x][y])
                dp[x][y] = dp[x][y + 1] + 1;
            if (dp[x][y] > ret)
                ret = dp[x][y];
        }
        return ret;
    }
};

于是仿照大佬的思路，先对节点排序，再按照排序顺序依次遍历：

class Point {
public:
    int ix, iy, iv;
    Point (int x, int y, int v) : ix(x), iy(y), iv(v) {}
};

class Solution {
public:
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        if (matrix.size() == 0)
            return 0;
        int row = matrix.size(), column = matrix[0].size();
        int dp[row][column];
        int MAX = 0, i, j;
        for (int i = 0; i < row; i ++) {
            for (int j = 0; j < column; j ++)
                dp[i][j] = 0;
        }
        vector<Point> vp;
        vp.reserve(row * column);
        for (int i = 0; i < row; i++)
            for (int j = 0; j < column; j++) {
                vp.push_back(Point(i, j, matrix[i][j]));
            }
        // 对坐标排序
        sort(vp.begin(), vp.end(), [](const Point &lhs, const Point &rhs){
            return lhs.iv < rhs.iv;
        });
        for (const auto &p : vp) {
            auto i = p.ix;
            auto j = p.iy;
            int up = i - 1, down = i + 1, left = j - 1, right = j + 1, node = dp[i][j], t = matrix[i][j];
            if (up >= 0 && matrix[up][j] < t)    
                node = dp[up][j];
            if (down < row && matrix[down][j] < t)    
                node = max (node, dp[down][j]);
            if (left >= 0 && matrix[i][left] < t)     
                node = max (node, dp[i][left]);
            if (right < column && matrix[i][right] < t)     
                node = max (node, dp[i][right]);
            node = max (node + 1, 1);
            dp[i][j] = node;
            if (MAX < node) MAX = node;
        }          
        return MAX;
    }
};