[Leetcode] 329. Longest Increasing Path in a Matrix 解题报告

题目：

Given an integer matrix, find the length of the longest increasing path.

From each cell, you can either move to four directions: left, right, up or down. You may NOT move diagonally or move outside of the boundary (i.e. wrap-around is not allowed).

Example 1:

nums = [
[9,9,4],
[6,6,8],
[2,1,1]
]

Return 

4

The longest increasing path is 

[1, 2, 6, 9]

.

Example 2:

nums = [
[3,4,5],
[3,2,6],
[2,2,1]
]

Return 

4

The longest increasing path is 

[3, 4, 5, 6]

. Moving diagonally is not allowed.
思路：

1、BFS：由于越小的数字其递减链越长，所以我们先对数据元素进行排序，然后依次从大的数据元素开始处理：对于每个元素，一旦发现周围有比它小的元素，并且其目前的路径长度小于当前元素的最长路径（已经是最终值了，将来不会再更新，请思考为什么？）加1，则更新。最终返回所有路径中的最大值即可。

2、DFS：DFS的好处是不需要对数据元素进行有序处理，但是朴素的DFS也存在重复计算的问题：例如对于图中所给出的测试用例，在其最长路径9,6,2,1上，我们计算9的过程中就已经把6,2和1的路径都计算过了，但是在碰到6的时候还需要再重复计算一次。一个有效的解决方法就是采用DFS+记忆。一旦计算出来了某个数据元素的最长路径，则将其保存下来，这样在后面的计算中，如果发现该位置上的元素已经被计算出来了，则直接利用所保存的结果。DFS的代码写出来比BFS要简洁一些。

代码：

1、BFS：

class Solution {
public:
int longestIncreasingPath(vector<vector<int>>& matrix) {
if(matrix
b65d
.size() == 0 || matrix[0].size() == 0) {
return 0;
}
int row_num = matrix.size(), col_num = matrix[0].size();
multimap<int, pair<int, int>> value_maps;
for(int i = 0; i < row_num; ++i) {
for(int j = 0; j < col_num; ++j) {
value_maps.insert(make_pair(matrix[i][j], make_pair(i, j)));
}
}
vector<vector<int>> paths(row_num, vector<int>(col_num, 1));
int max_path = 1;
for(auto it = value_maps.rbegin(); it != value_maps.rend(); ++it) {
int value = it->first;
int row = it->second.first, col = it->second.second;
if(row > 0 && matrix[row-1][col] < value) {
paths[row-1][col] = max(paths[row-1][col], paths[row][col] + 1);
max_path = max(max_path, paths[row-1][col]);
}
if(row < row_num - 1 && matrix[row+1][col] < value) {
paths[row+1][col] = max(paths[row+1][col], paths[row][col] + 1);
max_path = max(max_path, paths[row+1][col]);
}
if(col > 0 && matrix[row][col-1] < value) {
paths[row][col-1] = max(paths[row][col-1], paths[row][col] + 1);
max_path = max(max_path, paths[row][col-1]);
}
if(col < col_num - 1 && matrix[row][col+1] < value) {
paths[row][col+1] = max(paths[row][col+1], paths[row][col] + 1);
max_path = max(max_path, paths[row][col+1]);
}
}
return max_path;
}
};2、DFS：

class Solution {
public:
int longestIncreasingPath(vector<vector<int>>& matrix) {
if(matrix.size() == 0 || matrix[0].size() == 0) {
return 0;
}
int row = matrix.size(), col = matrix[0].size();
int ret = 0;
for(int i = 0; i < row; ++i){
for(int j = 0; j < col; ++j) {
ret = max(ret, dfs(matrix, i, j, LONG_MIN));
}
}
return ret;
}
private:
int dfs(vector<vector<int>>& matrix, int x, int y, long val) {
int row = matrix.size(), col = matrix[0].size();
if(x < 0 || x >= row || y < 0 || y >= col || matrix[x][y] <= val) {     // out of boundary or no-larger values
return 0;
}
if(hash.count(x * col + y)) {                                           // has already been calculated
return hash[x * col + y];
}
int len1 = dfs(matrix, x + 1, y, matrix[x][y]);
int len2 = dfs(matrix, x - 1, y, matrix[x][y]);
int len3 = dfs(matrix, x, y + 1, matrix[x][y]);
int len4 = dfs(matrix, x, y - 1, matrix[x][y]);
int max_len = max(max(len1, len2), max(len3, len4)) + 1;
hash[x * col + y] = max_len;
return max_len;
}
unordered_map<int, int> hash;
};