Java 在二维数组中查找最长的递增序列_Java_Matrix

Java 在二维数组中查找最长的递增序列

java matrix

Java 在二维数组中查找最长的递增序列,java,matrix,Java,Matrix,我已经研究这个问题有一段时间了，没能想出解决办法；我希望你能帮忙我想找出最长的递增数列。例如，如果我有以下4X4阵列： [![enter image description here][1]][1] int [] nums = { {97 , 47 , 56 , 36}, {35 , 57 , 41 , 13}, {89 , 36 , 98 , 75}, {25 , 45 , 26 , 17} }; 预期结果：

我已经研究这个问题有一段时间了，没能想出解决办法；我希望你能帮忙

我想找出最长的递增数列。例如，如果我有以下4X4阵列：

[![enter image description here][1]][1]

    int [] nums = {
        {97 , 47 , 56 , 36},
        {35 , 57 , 41 , 13},
        {89 , 36 , 98 , 75},
        {25 , 45 , 26 , 17}
    };

预期结果：返回8和LIS 17、26、36、41、47、56、57、97 我还没有答案，我正在努力找到它

17  (3,3)
26  (3,2)
36  (2,1)
41  (1,2)
47  (0,1)
56  (0,2)
57  (1,1)
97  (0,0)

我希望我的例子足够清楚

这是我的密码；当我试图找到最长的增长路径时，它不会向后，也不会对角。有人能帮我吗

public class Solution2 {
    static int[] dx = { 1, -1, 0, 0 };
    static int[] dy = { 0, 0, 1, -1 };
    public static int longestIncreasingPath(int[][] matrix) {
        if (matrix.length == 0)
            return 0;
        int m = matrix.length, n = matrix[0].length;
        int[][] dis = new int[m][n];
        int ans = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                ans = Math.max(ans, dfs(i, j, m, n, matrix, dis));
            }
        }
        return ans;
    }

    static int dfs(int x, int y, int m, int n, int[][] matrix, int[][] dis) {
        if (dis[x][y] != 0)
            return dis[x][y];

        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if (nx >= 0 && ny >= 0 && nx < m && ny < n && matrix[nx][ny] > matrix[x][y]) {
                dis[x][y] = Math.max(dis[x][y], dfs(nx, ny, m, n, matrix, dis));
            }
        }
        return ++dis[x][y];
    }

    public static void main(String[] args) {
        int arr[][] = { 
          { 97, 47, 56, 36 }, 
          { 35, 57, 41, 13 }, 
          { 89, 36, 98, 75 }, 
          { 25, 45, 26, 17 }
        };
        System.out.println(longestIncreasingPath(arr));
    }
}

公共类解决方案2{
静态int[]dx={1，-1,0,0}；
静态int[]dy={0,0,1，-1}；
公共静态int longestIncreasingPath（int[][]矩阵）{
如果（矩阵长度==0）
返回0；
int m=矩阵.length，n=矩阵[0]。长度；
int[]dis=新的int[m][n]；
int ans=0；
for（int i=0；i=0&&ny>=0&&nxmatrix[x][y]）{
dis[x][y]=Math.max（dis[x][y]，dfs（nx，ny，m，n，matrix，dis））；
}
}
return++dis[x][y]；
}
公共静态void main（字符串[]args）{
int arr[][]={
{ 97, 47, 56, 36 }, 
{ 35, 57, 41, 13 }, 
{ 89, 36, 98, 75 }, 
{ 25, 45, 26, 17 }
};
System.out.println（longestIncreasingPath（arr））；
}
}

据我所知，您尝试实施深度优先搜索，以查找递增顺序的最长路径。如果是这样的话，首先最好标记你访问过的数字。一个方便的解决方案是一个简单的解决方案。对于标记的数字，您可以使用它来检查特定数字是否已按递增顺序计数。这是给你的一个小提示

如果您仍然对深度优先搜索感到困惑，我建议您阅读，以便更好地理解该算法的全部内容

嗯，依我所知，您尝试实施深度优先搜索，以找到递增顺序的最长路径。如果是这样的话，首先最好标记你访问过的数字。一个方便的解决方案是一个简单的解决方案。对于标记的数字，您可以使用它来检查特定数字是否已按递增顺序计数。这是给你的一个小提示

如果您仍然对深度优先搜索感到困惑，我建议您阅读，以便更好地理解该算法的全部内容

HTH，evgeny

我假设我们正在寻找一个严格的递增序列（这在最初的问题描述中并不清楚）。然后，可以通过动态规划方法解决此问题：

1）将单元格按其值按降序排序

2）按降序指定从该单元格开始的最长路径的长度：

2a）如果您无法到达之前访问过的任何单元格，请分配1

2b）否则指定1+max（可到达的前一个单元格）

完成此操作后，总最大值为最长路径的长度。还可以通过在步骤2b）中记住max单元来找到路径本身

在示例中，这给出了：

                                            0,3 2,1
cell    98  97  89  75  57  56  47  45  41  36  36  35  26  25  17  13
length   1   1   1   2   2   3   4   2   5   6   6   7   7   7   8   7