题目:
给定一个整数矩阵,找出最长递增路径的长度。
对于每个单元格,你可以往上,下,左,右四个方向移动。 你不能在对角线方向上移动或移动到边界外(即不允许环绕)。
示例 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]。注意不允许在对角线方向上移动。
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/longest-increasing-path-in-a-matrix
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
思路:
这个题目标注为:困难级别。
确实,这个题目很难,不过想到了就比较容易过。。。
首先,这个题属于“查找类”,最简单的方法莫过于DFS与BFS两大搜索算法。
在这个题目中,不推荐使用BFS,用DFS是最好的选择:最长路径。
选定了方法,就写策略:
从左上角一直遍历到右下角,遍历完所有矩阵格,之后就可以得到一个最大值,即要求的最大路径长度。
但是这种方法缺陷很明显:复杂度过高(可能是O(n^n)阶,很高的复杂度了),必定超时。
分析复杂度高的原因:重复查找了。
所以,需要用空间换时间的做法,记忆化搜索过的节点所属的最长递增路径长度值。
这样就能将复杂度降低至:O(row*column*(e+v))。
其中row与column是矩阵的维度,e是边(因为可以上下左右移动),v是节点。
记忆化剪枝策略:
使用一个dp矩阵,定义:
dp[i][j]:节点[i,j]可以走的路径中最长的那一条路径的长度。
这个操作通过:
dp[nr][nc] = Math.max(dp[nr][nc], solve(matrix, nextr, nextc, dp)+1);
可以实现。解释一下:
max中,第一个不需要解释,懂得都懂;
// 第二个需要解释一下,即为从[nr,nc]出发到达其他可以达到节点的路径长度。
// 也是利用记忆化,来达到叠加最优、剪枝的效果。
最后,需要注意:
在上面的操作过后,dp[nr][nc]可能还是0(初始值),因为:
如果当前的节点四周的值都比它小(如题目中的示例1中的节点值为8的节点处),则无法向外走,即它自身为一条路径,只是这条路径只有它自己一个节点而已.
此时,需要:
当前节点的dp只能也必须赋值为1。(这个理由很好理解)
实现:
JAVA版:
package leetcode;
import java.util.Arrays;
/*
USER:LQY
DATE:2020/7/26
TIME:8:25
*/
public class leetcode_329 {
public static void main(String []args){
int [][]matrix = {
{9, 9, 4},
{6, 6, 8},
{2, 1, 1}
// {3, 4, 5},
// {3, 2, 6},
// {2, 2, 1}
};
System.out.println(new leetcode_329().longestIncreasingPath(matrix));
}
public int longestIncreasingPath(int[][] matrix) {
int row = matrix.length;
if(row == 0) return 0;
int column = matrix[0].length;
if(row==column && row==1){
return 1;
}
// int [][]book = new int[row][column];
int [][]dp = new int[row][column];
// for(int i = 0;i < row;i++)
// for(int j = 0;j < column;j++)
// dp[i][j] = 1;
// solve(matrix, 1, 0, 0, book, 1, dp);
int max = 0;
for(int i = 0;i < row;i++){
for(int j = 0;j < column;j++){
solve(matrix, i, j, dp);
max = Math.max(max, dp[i][j]);
}
}
return max;
}
int [][]dir = {{-1, 0},{0, 1},{1, 0},{0, -1}}; //上、右、下、左
public int solve(int [][]matrix, int nr, int nc, int [][]dp){
if(dp[nr][nc] != 0){
return dp[nr][nc];
}
int r = matrix.length;
int c = matrix[0].length;
// dp[nr][nc] = count; //记录
for(int i = 0;i < 4;i++){
int nextr = nr + dir[i][0];
int nextc = nc + dir[i][1];
if(nextc<0 || nextc>=c || nextr<0 || nextr>=r) continue;
// if(book[nextr][nextc] == 1) continue; //走过了
int nextv = matrix[nextr][nextc];
int nv = matrix[nr][nc];
if(nextv <= nv) continue; //递增情况下。不符合
// book[nextr][nextc] = 1;
// 关键语句:使得dp[nr][nc]更新为:从[nr,nc]出发能够到达的、递增排列的最长序列长度。
// max中,第一个不需要解释,懂得都懂;
// 第二个需要解释一下,即为从[nr,nc]出发到达其他可以达到节点的路径长度。
// 也是利用记忆化,来达到叠加最优、剪枝的效果。
dp[nr][nc] = Math.max(dp[nr][nc], solve(matrix, nextr, nextc, dp)+1);
// dp[nr][nc] = Math.max(dp[nr][nc], dp[nextr][nextc]);
// book[nextr][nextc] = 0;
}
// if(dp[nr][nc] == 0) dp[nr][nc] = 1; //这个判断很重要:如果当前的节点四周的值都比它小,则当前节点的dp只能也必须赋值为1.
return dp[nr][nc]==0?1:dp[nr][nc];
}
}
C语言版:(二维数组的分配还是有点麻烦555)
int dir[][2] = {{-1, 0},{0, 1},{1, 0},{0, -1}}; //上、右、下、左
int solve(int **matrix, int matrixSize, int matrixColSize,int nr, int nc, int **dp){
if(dp[nr][nc] != 0) return dp[nr][nc];
for(int i = 0;i < 4;i++){
int nextr = nr + dir[i][0];
int nextc = nc + dir[i][1];
if(nextc<0 || nextc>=matrixColSize || nextr<0 || nextr>=matrixSize) continue;
int nextv = matrix[nextr][nextc];
int nv = matrix[nr][nc];
if(nextv <= nv) continue; //递增情况下。不符合
// dp[nr][nc] = max(dp[nr][nc], solve(matrix, matrixSize, matrixColSize, nextr, nextc, dp)+1);
int nccc = solve(matrix, matrixSize, matrixColSize, nextr, nextc, dp)+1;
dp[nr][nc] = dp[nr][nc]>nccc? dp[nr][nc] : nccc;
}
if(dp[nr][nc] == 0) dp[nr][nc] = 1;
return dp[nr][nc];
}
int longestIncreasingPath(int** matrix, int matrixSize, int* matrixColSize){
if(matrixSize == 0)
return 0;
int **dp = (int **)malloc(matrixSize * sizeof(int *));
for(int i = 0;i < matrixSize;i++){
dp[i] = (int*)malloc((*matrixColSize) * sizeof(int));
for(int j = 0;j < *matrixColSize;j++)
dp[i][j] = 0;
}
int max = 0;
for(int i = 0;i < matrixSize;i++){
for(int j = 0;j < *matrixColSize;j++){
solve(matrix, matrixSize, *matrixColSize, i, j, dp);
max = max > dp[i][j]? max : dp[i][j];
}
}
return max;
}