Java 查找二维（MxM）阵列中的最长直线（垂直、水平或对角线）

使用给定的平方（MxM）矩阵查找最长直线的长度。（允许垂直、水平或对角线）（最长线条的长度=连续1的数量）

i、 e.） 输入：

输出：7（在这种情况下，第四个水平行是最长的行。）

我的java代码：

public class LongestLine {
    private int hmax = 0;
    private int vmax = 0;
    private int rdmax = 0; // right down direction
    private int ldmax = 0; // left down direction


    public int longestLine(int[][] grid) {

        for(int i = 0; i < grid.length; i++) {
            for(int j = 0; j < grid[i].length; j++) {
                if(grid[i][j] == 1) update(grid, i, j);
            }
        }

        return Math.max(Math.max(hmax, vmax), Math.max(rdmax, ldmax));
    }

    private void update(int[][] grid, int i, int j) {
        int h = 1, v = 1, rd = 1, ld = 1;

        if(j < grid[i].length - 1 && grid[i][j+1] == 1) h = updateH(grid, i, j+1, h);
        if(i < grid.length - 1 && grid[i+1][j] == 1) v = updateV(grid, i+1, j, v);
        if(j < grid[i].length - 1 && i < grid.length - 1 && grid[i+1][j+1] == 1) 
            rd = updateRD(grid, i+1, j+1, rd);
        if(j > 0 && i < grid.length - 1 && grid[i+1][j-1] == 1) 
            ld = updateLD(grid, i+1, j-1, ld);

        hmax = Math.max(h, hmax);
        vmax = Math.max(v, vmax);
        rdmax = Math.max(rd, rdmax);
        ldmax = Math.max(ld, ldmax);
    }

    private int updateH(int[][] grid, int i, int j, int h) {
        h++;
        if(j < grid[i].length - 1 && grid[i][j+1] == 1) h = updateH(grid, i, j+1, h);
        return h;
    }

    private int updateV(int[][] grid, int i, int j, int v) {
        v++;
        if(i < grid.length - 1 && grid[i+1][j] == 1) v = updateV(grid, i+1, j, v);
        return v;
    }

    private int updateRD(int[][] grid, int i, int j, int rd) {
        rd++;
        if(j < grid[i].length - 1 && i < grid.length - 1 && grid[i+1][j+1] == 1) 
            rd = updateRD(grid, i+1, j+1, rd);
        return rd;
    }

    private int updateLD(int[][] grid, int i, int j, int ld) {
        ld++;
        if(j > 0 && i < grid.length - 1 && grid[i+1][j-1] == 1) 
            ld = updateLD(grid, i+1, j-1, ld);
        return ld;
    }
}

公共类最长线路{
私有int hmax=0；
私有int vmax=0；
private int rdmax=0；//右下方向
private int ldmax=0；//左下方向
公共int长基线（int[][]网格）{
对于（int i=0；i0&&i0&&i

---

我的代码似乎可以工作，但我不确定这是否是最有效的代码。你觉得这样行吗？或者是否有更快/更简单的实现？（最好用Java格式回答。）

我认为你需要使用回溯技术，因为它在电路板上尽了一切可能

---

请阅读有关回溯的内容

此问题不清楚。你所说的最长行的长度是什么意思？如果你有正在运行的代码并且想要查看，你应该在@RavindraRanwala上询问一行是一个1的序列。@Andreas得到了它，谢谢。通过动态编程，你可以用O（M^2）的时间复杂度和O（M）的内存复杂度来实现它。

public class LongestLine {
    private int hmax = 0;
    private int vmax = 0;
    private int rdmax = 0; // right down direction
    private int ldmax = 0; // left down direction


    public int longestLine(int[][] grid) {

        for(int i = 0; i < grid.length; i++) {
            for(int j = 0; j < grid[i].length; j++) {
                if(grid[i][j] == 1) update(grid, i, j);
            }
        }

        return Math.max(Math.max(hmax, vmax), Math.max(rdmax, ldmax));
    }

    private void update(int[][] grid, int i, int j) {
        int h = 1, v = 1, rd = 1, ld = 1;

        if(j < grid[i].length - 1 && grid[i][j+1] == 1) h = updateH(grid, i, j+1, h);
        if(i < grid.length - 1 && grid[i+1][j] == 1) v = updateV(grid, i+1, j, v);
        if(j < grid[i].length - 1 && i < grid.length - 1 && grid[i+1][j+1] == 1) 
            rd = updateRD(grid, i+1, j+1, rd);
        if(j > 0 && i < grid.length - 1 && grid[i+1][j-1] == 1) 
            ld = updateLD(grid, i+1, j-1, ld);

        hmax = Math.max(h, hmax);
        vmax = Math.max(v, vmax);
        rdmax = Math.max(rd, rdmax);
        ldmax = Math.max(ld, ldmax);
    }

    private int updateH(int[][] grid, int i, int j, int h) {
        h++;
        if(j < grid[i].length - 1 && grid[i][j+1] == 1) h = updateH(grid, i, j+1, h);
        return h;
    }

    private int updateV(int[][] grid, int i, int j, int v) {
        v++;
        if(i < grid.length - 1 && grid[i+1][j] == 1) v = updateV(grid, i+1, j, v);
        return v;
    }

    private int updateRD(int[][] grid, int i, int j, int rd) {
        rd++;
        if(j < grid[i].length - 1 && i < grid.length - 1 && grid[i+1][j+1] == 1) 
            rd = updateRD(grid, i+1, j+1, rd);
        return rd;
    }

    private int updateLD(int[][] grid, int i, int j, int ld) {
        ld++;
        if(j > 0 && i < grid.length - 1 && grid[i+1][j-1] == 1) 
            ld = updateLD(grid, i+1, j-1, ld);
        return ld;
    }
}