Longest Increasing Path in a Matrix - LeetCode

Longest Increasing Path in a Matrix - LeetCode

题目：

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).

nums = [

[9,9,4],

[6,6,8],

[2,1,1]

]

Return 4

The longest increasing path is [1, 2, 6, 9].

想法比较简单，用一个与nums一样大的二维数组a存储结果，

a[i][j]

表示到达

nums[i][j]

这个位置的最长路径的长度。

一开始把a中所有元素设置成1（自己到达自己，长度是1），然后便利整个数组，如果

nums[i][j]

比它上方的数大，那么

a[i][j]=a[i-1][j]+1

（从nums[i-1][j]可以往下走一格），下、左、右这三个方向同理，从4个方向算出的结果中选出一个最大的，作为

a[i][j]

的值。

这样一直迭代下去，直到a中所有数不再变化。

代码：

class Solution {
public:
int longestIncreasingPath(vector< vector<int> >& matrix) {
int m,n;
m = matrix.size();
if (m == 0) return 0;
n = matrix[0].size();
if (n == 0) return 0;
vector< vector<int> > vv(m+1, vector<int>(n+1, 1));
// cout << 1111 << endl;
int temp, mmx = 0;
bool flag = true;
while (flag) {
flag = false;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
temp = vv[i][j];
if (i-1 >= 0 && matrix[i][j] < matrix[i-1][j]) vv[i][j] = max(vv[i][j], vv[i-1][j]+1);
if (j+1 < n && matrix[i][j] < matrix[i][j+1]) vv[i][j] = max(vv[i][j], vv[i][j+1]+1);
if (i+1 < m && matrix[i][j] < matrix[i+1][j]) vv[i][j] = max(vv[i][j], vv[i+1][j]+1);
if (j-1 >= 0 && matrix[i][j] < matrix[i][j-1]) vv[i][j] = max(vv[i][j], vv[i][j-1]+1);
if (vv[i][j] != temp) flag = true;
mmx = max(mmx, vv[i][j]);
}
}
}
return mmx;
}
};

比较一下别人的代码又会发现自己的有多蠢

class Solution {
public:
int longestIncreasingPath(vector<vector<int>>& matrix) {
int rows = matrix.size();
if (!rows) return 0;
int cols = matrix[0].size();

vector<vector<int>> dp(rows, vector<int>(cols, 0));
std::function<int(int, int)> dfs = [&] (int x, int y) {
if (dp[x][y]) return dp[x][y];
vector<vector<int>> dirs = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};
for (auto &dir : dirs) {
int xx = x + dir[0], yy = y + dir[1];
if (xx < 0 || xx >= rows || yy < 0 || yy >= cols) continue;
if (matrix[xx][yy] <= matrix[x][y]) continue;
dp[x][y] = std::max(dp[x][y], dfs(xx, yy));
}
return ++dp[x][y];
};

int ret = 0;
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
ret = std::max(ret, dfs(i, j));
}
}

return ret;
}
};

这是用了dfs+动态规划，对每个节点用一次dfs，找出到达这个节点的最大递增路径长度。dfs会产生很多中间结果，比如说我们要求

dp[i][j]

,那么我们必须先求出

dp[i][j-1]

（如果这个位置没有越界的话），这就是一个中间结果，而用dfs求出的

dp[i][j-1]

就是到达

[i][j-1]

这个位置的最大递增路径长度，所以可以把它记录下来，再次遇到的时候直接返回保存的值即可