Java 如何计算矩阵中每个正方形（较小矩阵）的长度

我正在解决一个涉及矩阵的算法任务。 我需要在一个较大的方格中计算每个内部方格（较小的矩阵）。 原始长度和下一个长度之间是否存在依赖关系？ 例如，我有以下矩阵：

1  2  3  4  5  6
7  8  9  10 11 12
13 14 15 16 17 18 
19 20 21 22 23 24 
25 26 27 28 29 30
31 32 33 34 35 36

如您所见，

Rows=6

，

Cols=6

，

Length=Rows*Cols

问题陈述：如何计算内部矩阵的长度：

8  9  10 11
14 15 16 17
20 21 22 23
26 27 28 29

最后一个呢

15 16
21 22

我能做的是：

for(int i = 0; i < row; i++){ 
    for(int j = 0; j < col; j++){
        //mirrored row and col e.g. 0 1 2 3 2 1 0
        int rowMir = i >= (int)Math.round(M/2.0d) ? (M - 1 - i) : i; 
        int colMir = j >= (int)Math.round(N/2.0d) ? (N - 1 - j) : j; 
        int depth = row > col ? col : row; //depth of inner square for each element in iteration. square's border in other words. 
        //In current matrix there are 3 inner squares (0, 1, 2)
    } 
}

for（inti=0；i=（int）数学圆（M/2.0d）？（M-1-i）：i；
int colMir=j>=（int）数学四舍五入（N/2.0d）？（N-1-j）：j；
int depth=row>col？col:row；//迭代中每个元素的内部正方形的深度。换句话说，正方形的边框。
//在当前矩阵中有3个内部正方形（0、1、2）
} 
}

它有用吗？我试着根据我得到的值来计算，但直到现在都没有成功。谷歌在这件事上什么也没给我

编辑
我正在寻找的解决方案是动态获取每个元素的矩阵大小。
[i][j]
处的值示例我已经计算了
深度，它所属的内部矩阵
 您只需在每次迭代时减少
2步
：

int minDim = Math.min(rows, columns);
for(int i = minDim ; i >= 0 ; i -= 2) {
    System.out.println("Inner length: " + ((rows - i) * (columns - i)))
}

您只需在每次迭代时减少
2
：

int minDim = Math.min(rows, columns);
for(int i = minDim ; i >= 0 ; i -= 2) {
    System.out.println("Inner length: " + ((rows - i) * (columns - i)))
}

如果您确实想要打印所有内部矩阵并获得计数，则可以执行以下操作：

public static void main (String[] args)
{
    /* Define Matrix */
    int matrixSize = 6;
    int[][] matrix = new int[][]{{1, 2, 3, 4, 5, 6 },
                                 {7, 8, 9, 10,11,12},
                                 {13,14,15,16,17,18},
                                 {19,20,21,22,23,24},
                                 {25,26,27,28,29,30},
                                 {31,32,33,34,35,36}};

    /* Initialize Count Counter */
    int count = 0;

    /* Count/Print Inner Matrices */                             
    for(int x = 2; x < matrixSize; x++) {
        for(int i = 0; i <= matrixSize - x; i++) {
            for(int j = 0; j <= matrixSize - x; j++) {
                /* Call Print Matrix Function */
                printMatrix(matrix, i, j, x);
                ++count; /* Increment Counter */
            }
        }
    }

    /* Print Actual Count */
    System.out.println("\nTotal Inner Square Matrices Count: " + count);
}

/**
 * Print Matrix
 * Arguments: Matrix, Row Index, Column Index, Matrix Size
**/
public static void printMatrix(int[][] matrix, int i, int j, int size) {
    System.out.println();
    /* Row Iterator */
    for(int iIndex = i; iIndex < i + size; iIndex++) {
        System.out.println();
        /* Column Iterator */
        for(int jIndex = j; jIndex < j + size; jIndex++) {
            System.out.print(" " + matrix[iIndex][jIndex]);
        }
    }
}

如果您确实想要打印所有内部矩阵并获得计数，则可以执行以下操作：

public static void main (String[] args)
{
    /* Define Matrix */
    int matrixSize = 6;
    int[][] matrix = new int[][]{{1, 2, 3, 4, 5, 6 },
                                 {7, 8, 9, 10,11,12},
                                 {13,14,15,16,17,18},
                                 {19,20,21,22,23,24},
                                 {25,26,27,28,29,30},
                                 {31,32,33,34,35,36}};

    /* Initialize Count Counter */
    int count = 0;

    /* Count/Print Inner Matrices */                             
    for(int x = 2; x < matrixSize; x++) {
        for(int i = 0; i <= matrixSize - x; i++) {
            for(int j = 0; j <= matrixSize - x; j++) {
                /* Call Print Matrix Function */
                printMatrix(matrix, i, j, x);
                ++count; /* Increment Counter */
            }
        }
    }

    /* Print Actual Count */
    System.out.println("\nTotal Inner Square Matrices Count: " + count);
}

/**
 * Print Matrix
 * Arguments: Matrix, Row Index, Column Index, Matrix Size
**/
public static void printMatrix(int[][] matrix, int i, int j, int size) {
    System.out.println();
    /* Row Iterator */
    for(int iIndex = i; iIndex < i + size; iIndex++) {
        System.out.println();
        /* Column Iterator */
        for(int jIndex = j; jIndex < j + size; jIndex++) {
            System.out.print(" " + matrix[iIndex][jIndex]);
        }
    }
}

原始矩阵是否始终为正方形（行=列）？如果外部矩阵为
6x6
，则根据您对内部矩阵的定义，它们的大小将为
4x4
和
2x2
，即每个内部矩阵的每侧大小减小2。不需要查看数据。因此，如果原始矩阵是
13x10
，那么内部矩阵将是：
11x8
，
9x6
，
7x4
，和
5x2
，所有矩阵的长度将是
130
，
88
，
54
，
28
，
10
。因此，如果起始矩阵是4x4，您想要内部所有不同1x1、2x2和3x3区域的元素数总和吗？或者，构建“内部”矩阵是否意味着只保留不在外部边界上的元素？@JeanLogeat，不总是这样，例如，它可能是
6x5
。我恐怕在“问题陈述”和显示的代码之间找不到任何关联。什么是
M
和
N
？当
行
和
列
从未更改时，为什么要反复计算
深度
？这两个循环的目的是什么
rowMir
和
colMir
将计算为数字0-2，因此它们永远不会是问题陈述中显示为第一个内部矩阵的
4x4
。原始矩阵是否始终为正方形（行=列）？如果外部矩阵为
6x6
，则根据您对内部矩阵的定义，它们的大小将是
4x4
和
2x2
，即每个内部矩阵每侧减小2个大小。不需要查看数据。因此，如果原始矩阵是
13x10
，那么内部矩阵将是：
11x8
，
9x6
，
7x4
，和
5x2
，所有矩阵的长度将是
130
，
88
，
54
，
28
，
10
。因此，如果起始矩阵是4x4，您想要内部所有不同1x1、2x2和3x3区域的元素数总和吗？或者，构建“内部”矩阵是否意味着只保留不在外部边界上的元素？@JeanLogeat，不总是这样，例如，它可能是
6x5
。我恐怕在“问题陈述”和显示的代码之间找不到任何关联。什么是
M
和
N
？当
行
和
列
从未更改时，为什么要反复计算
深度
？这两个循环的目的是什么
rowMir
和
colMir
将计算到数字0-2，因此它们永远不会是问题陈述中显示为第一个内部矩阵的
4x4
。既然您假设原始矩阵可能不是平方的（我同意），那么为什么您要假设内部矩阵必须是平方的？每次迭代只需将
行
和
列
减少2，直到其中一行低于1。@Andreas，这不等于他正在做的事情吗？在下面的循环中，我发现循环时
每个元素
都需要它。所以它应该类似于
（R-depth）*（C-depth）
。对于元素
[i][j]
，但不知怎的，它没有给出正确的answer@Yurets正确答案是什么？从“问题陈述”来看，它似乎是
16
和
4
，即显示的两个矩阵的长度。这就是你想要的答案吗？若不是那个问题，请澄清。该死，我已经测试了你们的解决方案。它起作用了。不知怎么的，我错过了。在我的例子中，我使用已经找到的
深度
，将其乘以2，并且相同。非常感谢。我接受你的回答：）既然你假设原始矩阵可能不是平方的（我也同意），为什么你还要假设内部矩阵必须是平方的？每次迭代只需将
行
和
列
减少2，直到其中一行低于1。@Andreas，这不等于他正在做的事情吗？在下面的循环中，我发现循环时
每个元素
都需要它。所以它应该类似于
（R-depth）*（C-depth）
。对于元素
[i][j]
，但不知怎的，它没有给出正确的answer@Yurets正确答案是什么？从“问题陈述”来看，它似乎是
16
和
4
，即