[LeetCode] 329、矩阵中的最长递增路径

题目描述

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

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

示例：

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

解题思路

难题，但是很经典。

• 朴素的深度优先搜索（超时）：（直觉）深度优先搜索可以找到从任何单元格开始的最长递增路径。我们可以对全部单元格进行深度优先搜索。在搜索期间更新路径的最大长度，并在搜索完成后得到答案。但是这样就遍历了所有的路径了，时间复杂度太高。时间复杂度：$O(2^{m+n})$。空间复杂度 ： $O(mn)$。 对于每次深度优先搜索，系统栈需要 $O(h)$ 空间，其中 $h$ 为递归的最深深度。最坏情况下， $O(h)=O(mn)$。

  补充：

  • 此题dfs往下递归的条件是“下一个格子中的数比当前的数大”。（参考代码）
  • 这里dfs搜索中并不需要visited数组来记录已经访问的元素，因为找的是升序的路径，所以进来了就不会再返回，用 visited 没有意义。

• dfs + 记忆矩阵（通过，推荐）：

  在计算中，记忆化是一种优化技术，它通过存储“昂贵”的函数调用的结果，在相同的输入再次出现时返回缓存的结果，以此加快程序的速度。

  在本问题中，我们多次递归调用 dfs(x, y) 。但是，如果我们已经知道四个相邻单元格的结果，就只需要常数时间。在搜索过程中，如果未计算过单元格的结果，我们会计算并将其缓存；否则，直接从缓存中获取之。（参考代码1，参考代码2）

补充：dfs时提前设置四个方向。

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

int new_x = x+dx[i], new_y = y+dy[i];

vector<vector<int> > memo(m, vector<int>(n, -1));  // 记忆矩阵 初始化方法  > >之间一定要有空格

参考代码

class Solution {
public:
    // 给定初始节点，dfs搜索
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        rows = matrix.size(); 
        if(rows == 0) return 0;
        cols = matrix[0].size(); 
        
        vector<vector<int> > memo(rows, vector<int>(cols, -1));  // 初始化方法
        int ans = 0;
        for(int i = 0; i < rows; i++){
            for(int j = 0; j < cols; j++){
                ans = max(ans, dfs(matrix, memo, i, j));
            }
        }
        
        return ans;
    }
    
    int dfs(vector<vector<int> > &matrix, vector<vector<int> > &memo, int x, int y){
        if(x < 0 || x >= rows || y < 0 || y >= cols)
            return 0;
        
        if(memo[x][y] != -1) 
            return memo[x][y];
        
        int dx[] = {1, -1, 0, 0};  // 小技巧：提前设置四个方向，更方便。
        int dy[] = {0, 0, 1, -1};
        int ans = 1;  // 这里的ans一定是从1开始的！（对于一个格子来说。最长递增路径最小为1，返回值最小为1）
        for(int i = 0; i < 4; i++){
            int new_x = x + dx[i];
            int new_y = y + dy[i];
            
            if(new_x >= 0 && new_x < rows && new_y >= 0 && new_y < cols && matrix[new_x][new_y] > matrix[x][y])
                ans = max(ans, dfs(matrix, memo, new_x, new_y) + 1);  // 这里的这个+1很重要
        }
        
        memo[x][y] = ans;
        return ans;
//        return memo[x][y] = ans;  // 这样写也行
    }

private:
    int rows, cols;
};