welcome to my blog
LeetCode Top Interview Questions 329. Longest Increasing Path in a Matrix (Java版; Hard)
题目描述
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:
Input: nums =
[
[9,9,4],
[6,6,8],
[2,1,1]
]
Output: 4
Explanation: The longest increasing path is [1, 2, 6, 9].
Example 2:
Input: nums =
[
[3,4,5],
[3,2,6],
[2,2,1]
]
Output: 4
Explanation: The longest increasing path is [3, 4, 5, 6]. Moving diagonally is not allowed.
第一次做; 动态规划; dp的重点是按序进行; 使用匿名函数写堆的比较器; dp[i][j]表示以(i,j)结尾的最长路径; 这道题最好的方法是使用memo数据, 并不是dp
//动态规划版本: dp[i][j]表示以(i,j)结尾的最长路径; dp的关键是按序进行, 本题中的顺序是先处理值小的数, 再处理值大的数, 所以先把数排个序
class Solution {
public int longestIncreasingPath(int[][] matrix) {
if(matrix==null || matrix.length==0 || matrix[0]==null || matrix[0].length==0)
return 0;
//按照value升序排序; 使用了匿名函数, 学习这种写法, 面试不扣分项
Queue<int[]> queue = new PriorityQueue<int[]>((a,b)->a[0]-b[0]);
int n = matrix.length, m = matrix[0].length;
for(int i=0; i<n; i++){
for(int j=0; j<m; j++){
//数组的三个元素分别是value, 行坐标, 列坐标
queue.add(new int[]{matrix[i][j], i, j});
}
}
//dp[i][j]表示以(i,j)结尾的最长路径
int[][] dp = new int[n][m];
// for(int[] a : dp){
// //初始时,dp[i][j]==1,表示以(i,j)结尾的最长路径为1
// Arrays.fill(a,1);
// }
int max=0;
while(!queue.isEmpty()){
int[] cur = queue.poll();
int value = cur[0];
int i = cur[1];
int j = cur[2];
//当前以(i,j)结尾的路径长度
int curMax = 1;
//上下左右
if(i-1>=0 && value > matrix[i-1][j]){
curMax = Math.max(curMax, 1+dp[i-1][j]);
}
if(i+1<n && value > matrix[i+1][j]){
curMax = Math.max(curMax, 1+dp[i+1][j]);
}
if(j-1>=0 && value > matrix[i][j-1]){
curMax = Math.max(curMax, 1+dp[i][j-1]);
}
if(j+1<m && value > matrix[i][j+1]){
curMax = Math.max(curMax, 1+dp[i][j+1]);
}
//更新dp
dp[i][j] = curMax;
//更新max
max = Math.max(max, curMax);
}
return max;
}
}
第一次做; 待优化的暴力递归, 使用memo数组记忆已经遍历过的位置, 拿空间换时间; 跟暴力递归的区别: 1)不再需要cur作为参数, 2)不再需要全局变量max; 最重要的是想清楚递归函数的递归逻辑
//使用memo[][]记录已经遍历过的点的结果
class Solution {
public int longestIncreasingPath(int[][] matrix) {
//input check
if(matrix==null || matrix.length==0 || matrix[0]==null || matrix[0].length==0)
return 0;
int n=matrix.length, m=matrix[0].length;
int[][] memo = new int[n][m];
int max = 0;
for(int i=0; i<n; i++){
for(int j=0; j<m; j++){
max = Math.max(max, core(memo,matrix, i, j));
}
}
return max;
}
//核心:要想清楚递归函数的递归逻辑, 本题中的递归逻辑: 返回从(i,j)出发的最长路径
//cur表示的是当前路径的长度 递归函数逻辑: 返回以(i,j)为起点的最长路径
public int core(int[][] memo, int[][] matrix, int i, int j){
//base case
if(memo[i][j] != 0)
return memo[i][j];
//max记录从(i,j)周围四个点出发, 能够返回的最大长度
int max = 0;
//四种移动方式不是互斥的, 而是都可以尝试
//上
if(isValid(matrix,i-1,j) && matrix[i-1][j] > matrix[i][j]){
//新条件新递归
max = Math.max(max, core(memo,matrix, i-1, j));
}
//下
if(isValid(matrix,i+1,j)&&matrix[i+1][j]>matrix[i][j]){
max = Math.max(max, core(memo,matrix, i+1, j));
}
//左
if(isValid(matrix,i,j-1)&&matrix[i][j-1]>matrix[i][j]){
max = Math.max(max, core(memo,matrix,i,j-1));
}
//右
if(isValid(matrix,i,j+1)&&matrix[i][j+1]>matrix[i][j]){
max = Math.max(max, core(memo,matrix,i,j+1));
}
//从(i,j)周围四个点出发能够返回的最大长度, 加上(i,j)这个点, 从而构成从(i,j)出发的最长路径
memo[i][j] = max+1;
return memo[i][j];
}
public boolean isValid(int[][] matrix, int i, int j){
int n=matrix.length, m=matrix[0].length;
return i>=0 && i<n && j>=0 && j<m;
}
}
第一次做; 暴力递归, 超时, 135 / 138; 关键: 什么时候更新max? 每次进入递归时更新max; cur是当前路径的长度; 四种选择是独立的, 不是互斥的!!
//暴力递归
class Solution {
public int max = 0;
public int longestIncreasingPath(int[][] matrix) {
//input check
if(matrix==null || matrix.length==0 || matrix[0]==null || matrix[0].length==0)
return 0;
int n=matrix.length, m=matrix[0].length;
for(int i=0; i<n; i++){
for(int j=0; j<m; j++){
core(matrix, i, j, 1);
}
}
return max;
}
//cur表示的是当前路径的长度
public void core(int[][] matrix, int i, int j, int cur){
//注意在哪里更新, 进入递归时就更新
max = Math.max(max, cur);
//四种移动方式不是互斥的, 而是都可以尝试
//上
if(isValid(matrix,i-1,j) && matrix[i-1][j] > matrix[i][j]){
core(matrix, i-1, j, cur+1);
}
//下
if(isValid(matrix,i+1,j)&&matrix[i+1][j]>matrix[i][j]){
core(matrix, i+1, j, cur+1);
}
//左
if(isValid(matrix,i,j-1)&&matrix[i][j-1]>matrix[i][j]){
core(matrix,i,j-1,cur+1);
}
//右
if(isValid(matrix,i,j+1)&&matrix[i][j+1]>matrix[i][j]){
core(matrix,i,j+1, cur+1);
}
}
public boolean isValid(int[][] matrix, int i, int j){
int n=matrix.length, m=matrix[0].length;
return i>=0 && i<n && j>=0 && j<m;
}
}
动态规划题解; dp[i][j]表示以(i,j)结尾的最长路径; 比较器是用匿名函数写的; dp的重点是需要按序进行，保证大的dp可以依赖小的dp
看大家用dfs记忆搜索的比较多，这里提供一个纯dp的思路。先按照元素值大小进行排序，同时记录元素的值，x，y坐标。再以元素值从小到大的顺序在matrix矩阵中进行dp累积。
dp的重点是需要按序进行，保证大的dp可以依赖小的dp，在这里表现为，递增较大的元素需要在较小元素计算后再计算，所以使用最小堆弹出当前最小元素，并使用记录的x,y坐标到matrix矩阵上判断周边元素大小，完成dp累积
public int longestIncreasingPath(int[][] matrix) {
if(matrix == null || matrix.length == 0 || matrix[0] == null || matrix[0].length == 0)
return 0;
//元素入最小堆，数组下标0-value，数组下标1-matrix中y坐标，数组下标2-matrix中x坐标，最小堆以value排序
Queue<int[]> minDump = new PriorityQueue<int[]>((pre,next) -> pre[0] - next[0]);
for(int y = 0; y < matrix.length; y++){
for(int x = 0; x < matrix[0].length; x++){
minDump.offer(new int[]{matrix[y][x],y,x});
}
}
//dp(记录当前元素累积到的最大递增路径长度)
int[][] dp = new int[matrix.length][matrix[0].length];
//实时记录最大路径，作为返回值返回
int maxLength = 0;
//元素从小到大开始dp(保证大的元素排在小的元素后被累积)
while(minDump.size() > 0){
int[] curElement = minDump.poll();
int value = curElement[0];
int y = curElement[1];
int x = curElement[2];
int curMax = 1;
//四个方向比较最大路径(如果matrix元素大于周边的元素，则最长路径在周边dp的基础上+1)
if(y > 0 && value > matrix[y - 1][x])
curMax = Math.max(curMax,dp[y - 1][x] + 1);
if(y < matrix.length - 1 && value > matrix[y + 1][x])
curMax = Math.max(curMax,dp[y + 1][x] + 1);
if(x > 0 && value > matrix[y][x - 1])
curMax = Math.max(curMax,dp[y][x - 1] + 1);
if(x < matrix[0].length - 1 && value > matrix[y][x + 1])
curMax = Math.max(curMax,dp[y][x + 1] + 1);
//累积dp
dp[y][x] = curMax;
//实时记录最大值
maxLength = Math.max(maxLength,curMax);
}
return maxLength;
}动态规划, 主要看看dp[i][j]的含义
力扣题解; 三种方法: 暴力递归; memo优化; 动态规划; 注意时间复杂度和空间复杂度的分析; 上下左右的遍历学一下, 别写4个if了
