java - 是否有一个函数可以按给定顺序不断增加矩阵中的数字

Question

我必须创建一个矩阵 (N*M)，其中每个单元格都根据特定遍历的顺序进行标记。

问题是我只为 (NN) 工作。我一直在寻找解决方案，以便它也适用于 (NM)。

例如N*M 示例:

1  2  5  10

4  3  6  11

9  8  7  12

N*N 的示例:

1  2  5  10 

4  3  6  11 

9  8  7  12 

16 15 14 13

2x4 看起来像:

1 2 5 7

4 3 6 8

4x2 看起来像:

1 2

4 3

5 6

7 8

代码

public static int matrix[][];
       public static void main(String[] args) {

        borderLayout(5);
        print();
       }

       public static void borderLayout(int size) {
           matrix = new int[size][size];
           for(int i = 0 ; i < size ; i ++) {
               fillBorder(i);
           }
       }

       public static void fillBorder(int n) {
           int number = n*n+1;
           int row = n;
           int column = 0;


           for(column = 0; column<=n; column++) {
               System.out.println("COLUMN DRAWING");
               matrix[row][column]=number++;
           }

           column--;

           for(row = n; row>0 ; row--){
               System.out.println("ROW DRAWING");
               matrix[row-1][column] = number++;
           }

           print();
           System.out.println("");

       }

       private static void print() {

              int x = matrix.length;
              int y = matrix[0].length;

              for (int i = 0; i < x; i++) {

                 for (int j = 0; j < y; j++) {

                    System.out.print(matrix[j][i]);
                    System.out.print(" ");
                    if (matrix[j][i] < 10) {
                       System.out.print(" ");
                    }
                 }

                 System.out.println();
              }

           }

Answer 1

在我的第一个回答下您的评论:

I was thinking also for another solution...With BFS. For a starting point let's say 0,0 you always go depth 1 every iteration so if you start from 0,0 you then do 1,0 1,1 0,1 and when you hit boundaries either row or column you increment the depth that means on the next iteration you go with 0,2 1,2 2,2 2,1 2,0 and if the matrix is nxm with n!=m you just skip the col or the row based on where you are(check matrix bound always m and n).

Forgot ot mention that in this way it will also work for letters as well.

我决定添加一个新答案而不是编辑第一个答案。

由于我对图和广度优先搜索不是很熟悉，所以我无法为基于 BSF 的算法提供任何建议。

但我想我理解了您想要如何进行的想法，这里是一种实现它的幼稚方法。每次迭代要采取的步骤

0,0
-----
0,1
1,1
1,0
-----
0,2
1,2
2,2
2,1
2,0
-----
0,3
1,3
2,3
3,3
3,2
3,1
3,0
...

不管矩阵是不是正方形，我最初关注的是正方形区域。例如，如果它是 4x6矩阵，我只看4x4部分并忽略最后两列。同样，如果行大于列。对于 7x5我会看看 5x5并忽略最后两行。在每次迭代中，我将使用两个内部循环，第一个循环递增行，第二个循环递减列。

与之前的回答相反，这次我将使用字符串数组来完成您的评论:

Forgot ot mention that in this way it will also work for letters as well.

static String[][] fillArray(int rows, int columns){
    char ch = 'A';
    String[][] matrix = new String[rows][columns];
    int square = Math.min(rows, columns);
    for(int i = 0; i < square; i++){
        String curr = String.valueOf(ch);
        for(int r = 0; r <= i ; r++){
            matrix[r][i] = curr;
        }
        for(int c = i-1; c >= 0; c--){
            matrix[i][c] = curr;
        }
        ch++;
    }
    return matrix;
}

例如使用参数 4x5 调用上述方法

public static void main(String[] args) {
    String[][] filled = fillArray(4,5);
    for(String[] row: filled){
        System.out.println(Arrays.toString(row));
    }
}

会导致

[A, B, C, D, null]
[B, B, C, D, null]
[C, C, C, D, null]
[D, D, D, D, null]

现在让我们看看被忽略的区域，它仍然充满了null。 ，即 rows > columns or rows < columns 的情况.为了简单起见，我将用 * 填写此区域。 .

static String[][] fillArray(int rows, int columns){
    char ch = 'A';
    String[][] matrix = new String[rows][columns];
    int square = Math.min(rows, columns);
    for(int i = 0; i < square; i++){
        String curr = String.valueOf(ch);
        for(int r = 0; r <= i ; r++){
            matrix[r][i] = curr;
        }
        for(int c = i-1; c >= 0; c--){
            matrix[i][c] = curr;
        }
        ch++;
    }

    ch = '*';
    if (rows > columns) {
        for (int i = square; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                matrix[i][j] = String.valueOf(ch);
            }
        }
    }
    if (rows < columns) {
        for (int i = square; i < columns; i++) {
            for (int j = 0; j < rows; j++) {
                matrix[j][i] = String.valueOf(ch);
            }
        }
    }
    return matrix;
}

调用 fillArray(4,6)

public static void main(String[] args) {
    String[][] filled = fillArray(4,6);
    for(String[] row: filled){
        System.out.println(Arrays.toString(row));
    }
}

现在应该导致:

[A, B, C, D, *, *]
[B, B, C, D, *, *]
[C, C, C, D, *, *]
[D, D, D, D, *, *]

这篇文章比我想象的要长。但我希望它很容易理解。