如何返回这样的多维数组？

Question

方法int[][] labelPath(int n, int[][] points) 创建一个长度为n 的新方阵并将其返回。 data0 中的每一行都描述了二维数组中的一个点。 0 列始终用于列索引，1 列用于点的行索引。如果返回数组到达data0 中的每个点，则返回值-1。在所有其他点，返回数组包含值 n。

例如：n = 4 和 data0 = {{3, 0}, {0, 1}, {2, 2}} 应该返回：

[[4, 4, 4, -1], [-1, 4, 4, 4], [4, 4, -1, 4], [4, 4, 4, 4]]

到目前为止我的代码：

int[][] labelPath(int n, int[][] points) {
    int[][] help = new int[n][n];
    for (int i = 0; i < input.length; i++) {
        for (int j = 0; j < input[i].length; j++) {
            int row = input[1].length;
            int column = input[0].length;
            for (int k = 0; k < help.length; k++) {
                for (int l = 0; l < help[k].length; l++) {
                    if (help[i][j] == input[row][column]) {
                        help[i][j] = -1;
                    } else {
                        help[i][j] = n;
                    }
                }
            }
        }
    }
    return help;
}

Answer 1

您可以非常简单地执行以下操作：

int[][] nPoints = { { 3, 0 }, { 0, 1 }, { 2, 2 } };
int[][] ret = labelPath(4, nPoints);
for (int[] r : ret) {
    System.out.println(Arrays.toString(r));
}

打印

[4, 4, 4, -1]
[-1, 4, 4, 4]
[4, 4, -1, 4]
[4, 4, 4, 4]

public static int[][] labelPath(int n, int[][] nPoints) {
    int[][] arr = new int[n][n];
    int[] row = new int[n];
    for (int i = 0; i < n; i++) {
        row[i] = 4;
    }
    // set each row to an array of n elements.
    for (int i = 0; i < n; i++) {
        arr[i] = row.clone(); // new instance each time.
    }
    
    // make the changes
    for (int[] p : nPoints) {
        arr[p[1]][p[0]] = -1;
    }
    return arr;
}

Answer 2

您可以使用流来创建这样的数组：

public static int[][] labelPath(int n, int[][] points) {
    // create a new empty 2d array filled with zeros
    int[][] matrix = new int[n][n];
    // set all array elements to 'n'
    Arrays.setAll(matrix, row -> {
        Arrays.fill(matrix[row], n);
        return matrix[row];
    });
    // iterate over the points array and set the corresponding elements to '-1'
    Arrays.stream(points).forEach(row -> matrix[row[1]][row[0]] = -1);
    return matrix;
}

// test
public static void main(String[] args) {
    int n = 4;
    int[][] data0 = {{3, 0}, {0, 1}, {2, 2}};
    int[][] matrix = labelPath(n, data0);

    // output
    Arrays.stream(matrix).map(Arrays::toString).forEach(System.out::println);
}

[4, 4, 4, -1]
[-1, 4, 4, 4]
[4, 4, -1, 4]
[4, 4, 4, 4]

---

^{另见：What is the most efficient way to create a 2d string array of initally repetitive data?}

Answer 3

创建4's 的help[n][n] 数组。

int[][] help = new int[n][n];
for(int row = 0; row < help.length; row++){
    for(int col = 0; col < 4; col++){
        help[row][col] = 4;
    }
}

根据data0数组改变值。

int [][]data0 = {{3, 0}, {0, 1}, {2, 2}} ;

for(int row = 0; row < data0.length; row++){
    int ar[] = new int[2];
    for(int col = 0, i = 0; col < data0[row].length; col++, i++){
        ar[i] = data0[row][col];
    }
    help[ar[1]][ar[0]] = -1;
}

打印help[][]数组。

for(int row = 0; row < help.length; row++){
    for(int col = 0; col < help.length; col++){
        System.out.print(help[row][col] + " ");
    }
    System.out.println();
}

输出：

4 4 4 -1 
-1 4 4 4 
4 4 -1 4 
4 4 4 4