BM61矩阵最长递增路径
描述
给定一个 n 行 m 列矩阵 matrix ,矩阵内所有数均为非负整数。 你需要在矩阵中找到一条最长路径,使这条路径上的元素是递增的。并输出这条最长路径的长度。
这个路径必须满足以下条件:
1. 对于每个单元格,你可以往上,下,左,右四个方向移动。 你不能在对角线方向上移动或移动到边界外。
2. 你不能走重复的单元格。即每个格子最多只能走一次。
数据范围:,
进阶:空间复杂度 ,时间复杂度
示例1
输入:
返回值:
示例2
输入:
返回值:
Java代码
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
* 递增路径的最大长度
* @param matrix int整型二维数组 描述矩阵的每个数
* @return int整型
*/
int maxPath = 0;
public int solve (int[][] matrix) {
// write code here
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[0].length; j++) {
findPath(matrix, i, j, 0, -1);
}
}
return maxPath;
}
void findPath (int[][] matrix, int i, int j, int num, int lastNum) {
if (i < 0 || i >= matrix.length || j < 0
|| j >= matrix[0].length || matrix[i][j] <= lastNum) {
maxPath = Math.max(maxPath, num);
return;
}
++ num;
findPath(matrix, i + 1, j, num, matrix[i][j]);
findPath(matrix, i, j + 1, num, matrix[i][j]);
findPath(matrix, i - 1, j, num, matrix[i][j]);
findPath(matrix, i, j - 1, num, matrix[i][j]);
}
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
- 30.
- 31.
- 32.
- 33.
- 34.
- 35.
import java.util.*;
public class Solution {
int ans=0;
public int solve (int[][] matrix) {
int m=matrix.length;
int n=matrix[0].length;
int[][] used=new int[m][n]; //是否走过
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
build(matrix,i,j,-1,0);//此时,最长递增路径长度为0
}
}
return ans;
}
public void build(int[][] matrix,int i,int j,int pre,int len){
//递增,不包括等于
int m=matrix.length;
int n=matrix[0].length;
if(i<0||j<0||i>=m||j>=n||matrix[i][j]<=pre){
ans=Math.max(ans,len);
return;
}
pre=matrix[i][j];
build(matrix,i,j-1,pre,len+1);
build(matrix,i,j+1,pre,len+1);
build(matrix,i-1,j,pre,len+1);
build(matrix,i+1,j,pre,len+1);
}
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
- 30.
import java.util.*;
public class Solution {
// 向上的向量
private static final int[] UP = {-1, 0};
// 向下的向量
private static final int[] DOWN = {1, 0};
// 向左的向量
private static final int[] LEFT = {0, -1};
// 向右的向量
private static final int[] RIGHT = {0, 1};
// 上下左右的向量
private static final int[][] DIRECTIONS = {UP, DOWN, LEFT, RIGHT};
// 最长递增路径
int ans;
public int solve (int[][] matrix) {
ans = 0;
boolean[][] path = new boolean[matrix.length][matrix[0].length];
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[0].length; j++) {
path[i][j] = true;
backTrack(matrix, i, j, 1, path);
path[i][j] = false;
}
}
return ans;
}
private void backTrack(int[][] matrix, int x, int y, int len,
boolean[][] path) {
ans = Math.max(ans, len);
for (int[] direction : DIRECTIONS) {
int nX = direction[0] + x;
int nY = direction[1] + y;
// 越界了
if (nX < 0 || nX >= matrix.length || nY < 0 || nY >= matrix[x].length) {
continue;
}
// 不能走回头路
if (path[nX][nY]) {
continue;
}
// 不符合递增序列的要求
if (matrix[nX][nY] <= matrix[x][y]) {
continue;
}
path[nX][nY] = true;
backTrack(matrix, nX, nY, len + 1, path);
path[nX][nY] = false;
}
}
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
- 30.
- 31.
- 32.
- 33.
- 34.
- 35.
- 36.
- 37.
- 38.
- 39.
- 40.
- 41.
- 42.
- 43.
- 44.
- 45.
- 46.
- 47.
- 48.
- 49.
- 50.
- 51.