Java二维数组递减最长路径_【LeetCode】329. 矩阵中的最长递增路径(深入理解DFS)...

题目链接

题目描述

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

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

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

解题思路

DFS+记忆化搜索

这题很容易想到利用DFS进行解决，但是本题单单采用DFS是没办法解决的，必须加上记忆化搜索。那什么是记忆化搜索呢？看看以下的问题，你就能明白什么情况要加上记忆化搜索

Q：我们之前做过连通块的题目，该题目要求你算出一共有多少个连通块，如果将题目更改一下，问你如何求出面积最大的连通块呢？

A：因为题目中我们肯定是需要对比多个连通块之间的面积，倘若你用一个变量去存储面积最大的连通块，该值也会因为DFS递归函数弹栈而改变，所以我们必须利用其他数据结构对值进行记录，这就是记忆化搜索，一般都是采用和地图规模一样大的二维数组。

弄清了DFS+记忆化搜索的概念，回到本题：

本题类似，每个元素都有4种状态可以选择，上下左右，然后套用递归模板即可。

注意：再写递归函数的时候，我们必须要理解这个递归函数表达的意义，否则很容易绕进去，以AC代码C++为例，f(int i,int j)该递归函数的意思表示：到matrix[i][j]这个元素的递增路径长度，所以也能理解f(aa,bb)+1中+1的含义：到matrix[aa][bb]的长度为f(aa,bb)，则到下一个满足条件的元素的递增路径长度当然是在此基础上+1.

AC代码

C++版本

classSolution {public:

vector>dp;

vector>data;int dx[4] = {-1, 1, 0, 0};int dy[4] = {0, 0, -1, 1};int ans = 0;intn, m;int f(int i, intj) {//cout << i << " " << j << endl;

//递归必须要有出口和剪枝　　 //if就是递归的剪枝

if (dp[i][j]) returndp[i][j];else{

dp[i][j]= 1;for (int k = 0; k < 4; k ++) {int aa = i + dx[k], bb = j +dy[k];if (aa < 0 || aa >= n || bb < 0 || bb >= m) continue;if (data[aa][bb] > data[i][j]) dp[i][j] = max(dp[i][j], f(aa, bb) + 1);//当递归返回值不是void的时候，通常递归表达式都需要做+或者其他运算，例如本题f(aa,bb)+1

}

ans=max(ans, dp[i][j]);

cout<

cout<

}

}int longestIncreasingPath(vector>&matrix) {

n=matrix.size();

data=matrix;if (n == 0) return 0;

m= matrix[0].size();

dp= vector>(n, vector(m, 0));for (int i = 0; i < n; i ++) {for (int j = 0; j < m; j ++) {if (dp[i][j] == 0) f(i, j);

ans=max(ans, dp[i][j]);

}

}returnans;

}

};

以示例2为例子，在源代码中添加两个cout语句，方便理解递归。

示例 2:

输入: nums =

[

[3,4,5],

[3,2,6],

[2,2,1]

]

输出: 4

Java版本

classSolution {int[][] dir = {{0,1},{0,-1},{1,0},{-1,0}};int ans = 0;public int dfs(int[][] matrix,int x,int y,int[][] dp){//递归必须要有出口和剪枝

if(dp[x][y] != 0) returndp[x][y];else{

dp[x][y]= 1;for(int i = 0; i < 4; i++){int xx = x + dir[i][0];int yy = y + dir[i][1];if(test(matrix,xx,yy) == false) continue;if(matrix[xx][yy] >matrix[x][y]){

dp[x][y]= Math.max(dp[x][y], dfs(matrix,xx,yy,dp) + 1);

}

}

ans=Math.max(ans,dp[x][y]);returndp[x][y];

}

}public boolean test(int[][] matrix,int x,inty){if(x < 0 || x >= matrix.length) return false;if(y < 0 || y >= matrix[0].length) return false;return true;

}public int longestIncreasingPath(int[][] matrix) {if(matrix.length == 0 || matrix[0].length == 0) return 0;int[][] dp = new int[matrix.length][matrix[0].length];for(int i = 0; i < matrix.length; i++){for(int j = 0; j < matrix[0].length; j++){

dfs(matrix,i,j,dp);

}

}returnans;

}

}