题目描述
给定一个整数矩阵,找出最长递增路径的长度。
对于每个单元格,你可以往上,下,左,右四个方向移动。 你不能在对角线方向上移动或移动到边界外(即不允许环绕)。
示例:
输入: nums =
[
[9,9,4],
[6,6,8],
[2,1,1]
]
输出: 4
解释: 最长递增路径为 [1, 2, 6, 9]。
解题思路
难题,但是很经典。
-
朴素的深度优先搜索(超时):(直觉)深度优先搜索可以找到从任何单元格开始的最长递增路径。我们可以对全部单元格进行深度优先搜索。在搜索期间更新路径的最大长度,并在搜索完成后得到答案。但是这样就遍历了所有的路径了,时间复杂度太高。时间复杂度: O ( 2 m + n ) O(2^{m+n}) O(2m+n)。空间复杂度 : O ( m n ) O(mn) O(mn)。 对于每次深度优先搜索,系统栈需要 O ( h ) O(h) O(h) 空间,其中 h h h 为递归的最深深度。最坏情况下, O ( h ) = O ( m n ) O(h) = O(mn) 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;
};