动态规划法求解矩阵中最长的递增路径长度

最新推荐文章于 2024-07-20 22:18:37 发布

weixin_34192732

最新推荐文章于 2024-07-20 22:18:37 发布

阅读量304

点赞数

CC 4.0 BY-SA版权

文章标签：数据结构与算法 java

原文链接：http://www.cnblogs.com/zhazhapan/p/java_dp_max_matrix_length.html

本文介绍了一个寻找二维矩阵中最长递增路径的问题，并提供了一个使用动态规划解决该问题的Java实现。通过递归地检查每个单元格周围的四个方向，确保递增顺序并记录最长路径。

给定一个整数矩阵,找到增加最长路径的长度。

从每一个单元格,你可以移到四个方向:左,右,向上或向下。你不能移到对角线移动或移动以外的边界(即缠绕是不允许的)。

Example 1:

nums = [

[9,9,4],

[6,6,8],

[2,1,1]]

Return 4
The longest increasing path is [1, 2, 6, 9].

Example 2:

nums = [

[3,4,5],

[3,2,6],

[2,2,1]]

Return 4
The longest increasing path is [3, 4, 5, 6]. Moving diagonally is not allowed.

Here is my code



package com.zhazhapan.algorithm.dynamicprogramming;

import java.util.Arrays;

public class PathProblem { public static void main(String[] args) { // TODO Auto-generated method stub int[][] test={{1,6,12,1,3},{8,4,6,10,5},{12,11,7,12,2},{2,3,4,1,13},{14,6,0,14,13}}; System.out.println(longestIncreasingPath(test)); }

static int[][] Lens;

public static int longestIncreasingPath(int[][] matrix) {
    if (matrix.length == 0) {
        return 0;
    }
    Lens = new int[matrix.length][matrix[0].length];
    int pathLen = 0;
    for (int i = 0; i &lt; Lens.length; i++) {
        for (int j = 0; j &lt; Lens[i].length; j++) {
            Lens[i][j] = -1;
        }
    }
    for (int i = 0; i &lt; matrix.length; i++) {
        for (int j = 0; j &lt; matrix[i].length; j++) {
            pathLen = Math.max(pathLen, requestPathLength(matrix, i, j));
        }
    }
    return pathLen + 1;
}
public static int requestPathLengths(int[][] matrix, int i, int j) {
    if (Lens[i][j] != -1) {
        return Lens[i][j];
    }
    int a = 0;
    if (i - 1 &gt; -1 && matrix[i][j] &lt; matrix[i - 1][j]) {
        a = 1 + requestPathLength(matrix, i - 1, j);
    }
    int b = 0;
    if (i + 1 &lt; matrix.length && matrix[i][j] &lt; matrix[i + 1][j]) {
        b = 1 + requestPathLength(matrix, i + 1, j);
    }
    int c = 0;
    if (j - 1 &gt; -1 && matrix[i][j] &lt; matrix[i][j - 1]) {
        c = 1 + requestPathLength(matrix, i, j - 1);
    }
    int d = 0;
    if (j + 1 &lt; matrix[0].length && matrix[i][j] &lt; matrix[i][j + 1]) {
        d = 1 + requestPathLength(matrix, i, j + 1);
    }
    Lens[i][j] = Math.max(Math.max(a, b), Math.max(c, d));
    return Lens[i][j];
}

}

转载于:https://www.cnblogs.com/zhazhapan/p/java_dp_max_matrix_length.html