Leetcode汇总贴: leetcode经典编程题目(Java实现)
leetcode题目
矩阵中的最长递增路径 -- leetcode 329
题目描述
给定一个整数矩阵，找出最长递增路径的长度。
对于每个单元格，你可以往上，下，左，右四个方向移动。 你不能在对角线方向上移动或移动到边界外（即不允许环绕）。
示例 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
思路
方案1、DFS+记忆数组
方案2、动态规划+递归
代码
package com.my.test.leetcode.array;
import java.util.ArrayList;
import java.util.List;
/**
* 题目：
* 矩阵中的最长递增路径 -- leetcode 329
*
* 题目描述：
给定一个整数矩阵，找出最长递增路径的长度。
对于每个单元格，你可以往上，下，左，右四个方向移动。 你不能在对角线方向上移动或移动到边界外（即不允许环绕）。
示例 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
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
*/
public class LongestIncreasingPath
{
/**
* 思路：
* DFS+记忆数组，但是性能较低，可修改为DFS+dp
*/
public int longestIncreasingPath(int[][] matrix) {
if (matrix == null || matrix.length <= 0 || matrix[0].length <= 0) {
return 0;
}
int max = 0;
int row = matrix.length;
int col = matrix[0].length;
for (int i=0; i(), maxLen);
return maxLen[0];
}
private void getLongestIncreasingPath(int[][] matrix, boolean[][] visited, int row, int col,
int i, int j, List cache, int[] maxLen) {
if (illegal(visited, row, col, i, j)) {
return;
}
int cur = matrix[i][j];
if (cache.isEmpty() || cache.get(cache.size()-1) < cur) {
// 找到下一个满足条件的递增元素
cache.add(cur);
visited[i][j] = true;
maxLen[0] = Math.max(maxLen[0], cache.size());
// 寻找下一个
getLongestIncreasingPath(matrix, visited, row, col, i-1, j, cache, maxLen);
getLongestIncreasingPath(matrix, visited, row, col, i+1, j, cache, maxLen);
getLongestIncreasingPath(matrix, visited, row, col, i, j-1, cache, maxLen);
getLongestIncreasingPath(matrix, visited, row, col, i, j+1, cache, maxLen);
// 回溯
cache.remove(cache.size()-1);
visited[i][j] = false;
}
}
private boolean illegal(boolean[][] visited, int row, int col,
int i, int j) {
return i<0 || i>=row || j<0 || j>=col || visited[i][j]== true;
}
/**
* 思路：
* DFS+dp
* 1、dp[i][j]表示数组中以(i,j)为起点的最长递增路径的长度，初始将dp数组都赋为0，
* 2、递归调用时，遇到某个位置(x, y), 如果dp[x][y]不为0的话，我们直接返回dp[x][y]即可，不需要重复计算。
* 3、以数组中每个位置都为起点调用递归来做，比较找出最大值。在以一个位置为起点用DFS搜索时，对其四个相邻位置进行判断，
* 如果相邻位置的值大于上一个位置，则对相邻位置继续调用递归，并更新一个最大值，搜素完成后返回即可
*/
public int longestIncreasingPathII(int[][] matrix) {
if (matrix == null || matrix.length <= 0 || matrix[0].length <= 0) {
return 0;
}
int max = 0;
int row = matrix.length;
int col = matrix[0].length;
int[][] dp = new int[row][col];
for (int i=0; i 0) {
return dp[i][j];
}
int max = 1;
for (int[] path : paths) {
int x = i + path[0];
int y = j + path[1];
// 可以继续搜索
if (x >= 0 && x = 0 && y < col && matrix[x][y] > matrix[i][j]) {
int len = 1 + dfs(matrix, dp, row, col, x, y);
max = Math.max(max, len);
}
}
dp[i][j] = max;
return max;
}
public static void main(String[] args)
{
int[][] matrix = {{3,4,5},
{3,2,6},
{2,2,1}};
System.out.println(new LongestIncreasingPath().longestIncreasingPathII(matrix));
}
}
