递归/回溯（六）矩阵最长递增路径

BM61矩阵最长递增路径

描述

给定一个 n 行 m 列矩阵 matrix ，矩阵内所有数均为非负整数。 你需要在矩阵中找到一条最长路径，使这条路径上的元素是递增的。并输出这条最长路径的长度。

这个路径必须满足以下条件：

1. 对于每个单元格，你可以往上，下，左，右四个方向移动。 你不能在对角线方向上移动或移动到边界外。

2. 你不能走重复的单元格。即每个格子最多只能走一次。

数据范围：$1≤�,�≤1000$，$0≤������[�][�]≤1000$

进阶：空间复杂度 $�(��)$ ，时间复杂度 $�(��)$

示例1

输入：

[[1,2,3],[4,5,6],[7,8,9]]

返回值：

5

说明：

1->2->3->6->9即可。当然这种递增路径不是唯一的。

示例2

输入：

[[1,2],[4,3]]

返回值：

4

说明：

1->2->3->4

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]);
    }
}

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);
    }
}

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;
        }
    }
}