如何将平方矩阵分解为平方子矩阵？

Question

我正在尝试创建一个程序，该程序从0和1的平方矩阵返回1的最大平方子矩阵。 现在，我已经弄清楚了如何从等于1的每个数字开始将平方分解成一个平方子矩阵。问题是，随着程序开始距离矩阵的起点越来越远，它突然越界，我怀疑这与它如何计算每个子矩阵从矩阵的哪一部分开始有关。

这是我的代码：

    public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    System.out.print("Enter the number of rows and columns in the matrix (only one input, this is a square matrix): ");
    int dimensions = input.nextInt();
    int[][] matrix = new int[dimensions][dimensions];
    for (int i = 0; i < matrix.length; i++) {
        for (int j = 0; j < matrix[i].length; j++) {
            int n = input.nextInt();
            if (n == 0 || n == 1)
                matrix[i][j] = n;
            else
                System.out.print("Input only 0 or 1");
        }
    }
    int[] largestBlock = findLargestBlock(matrix);
}
public static int[] findLargestBlock(int[][] m) {
    int[] solution = new int[3];
    //find rows with most consecutive 1's, then find columns with the same # of consecutive 1's
    for (int i = 0; i < m.length; i++) {
        for (int j = 0; j < m[i].length; j++) {
            //"origin" for each iteration is (i, j)
            if (m[i][j] == 1)
                if (isSquare(m, i, j) == true) {
                    solution[0] = i; solution[1] = j; solution[2] = getSize(m, i, j);
                }
        }
    }
    return solution;
}
public static boolean isSquare(int[][] m, int i, int j) {
    int k = m.length - i;
    if (m[0].length - j < k)
        k = m.length - j;
    if (k < 2)
        return false;
    int[][] testSquare = new int[k][k];
    for (int y = i; y < m.length - i; y++) {
        for (int x = j; x < m[i].length - j; x++) {

            testSquare[y - i][x - j] = m[y][x];
        }
    }
    for (int y = 0; y < testSquare.length; y++) {
        for (int x = 1; x < testSquare[y].length; x++) {
            if (testSquare[y][x] != testSquare[y][x - 1])
                return false;
        }
    }
    for (int x = 0; x < testSquare[0].length; x++) {
        for (int y = 1; y < testSquare.length; y++) {
            if (testSquare[y][x] != testSquare[y - 1][x])
                return false;
        }
    }
    return true;
}

public static int getSize(int[][] m, int i, int j) {
    int k = m.length - i;
    if (m[0].length - j < k)
        k = m.length - j;
    return k;
}

我确定程序的这一部分是导致此问题的原因，显然其中存在一些缺陷，无法将数组x-或y-值发送出去：

    public static boolean isSquare(int[][] m, int i, int j) {
    int k = m.length - i;
    if (m[0].length - j < k)
        k = m.length - j;
    if (k < 2)
        return false;
    int[][] testSquare = new int[k][k];
    for (int y = i; y < m.length - i; y++) {
        for (int x = j; x < m[i].length - j; x++) {

            **testSquare[y - i][x - j] = m[y][x];**
        }
    }

对于星号/粗体字的行，我感到很困惑，因为我认为这是导致问题的行。 但是，我不确定它是怎么引起问题的。

Answer 1

我认为您正在寻找的循环是这样的-由于testSquare是正方形的，因此请确保从0开始到k枚举，然后找到其他矩阵索引-m永远不会超过k，因为k是最小值，所以它从i和j，然后转到i + k和j + k max。

if (m[i].length - j < k)
    k = m[i].length - j;

for (int y = 0; y < k; y++) {
    for (int x = 0; x < k; x++) {

        testSquare[y][x] = m[i+y][j+x];
    }
}