Question

如果我有一个2D数组，如下所示，我需要得到最顶行和最左列（一个值）的最大值，并存储该值的坐标（I，J）。然后我需要考虑该值右下角的子阵列，并再次从最顶行或最左列找到最大值。这将在整个2D阵列中继续进行，这样我最终将得到所有值的Nx2坐标数组。例如，在显示的矩阵中，值应为4,3,2,1和0，坐标为（0,0），（1,1），（3,2），（4,3），（5），4）分别。

我尝试过以下但是每个子阵列的左上角总是从对角线（即（0,0），（1,1）......）开始，而不是紧接在下面和右边的值先前的最大值。例如，如果先前的最大值具有坐标（3,2），则下一个子阵列的左上角应为（4,3）。

// Top left corner of subarray set each time.

for(int p = 0; p < myMatrix.length; p++){  
    int maximum = myMatrix[p][p];
       coordinates[p][0] = p;
       coordinates[p][1] = p;

// Iterates through leftmost column of subarray.
    for(int i = p; i < table_data.length; i++){  
        if(maximum <= myMatrix[i][p]){            
           maximum = myMatrix[i][p];
           coordinates[p][0] = i;
           coordinates[p][1] = p;
       }
    }

//Iterates through topmost row of subarray. 

    for(int j = p; j < myMatrix[0].length; j++){ 
        if(maximum <= table_data[p][j]){           
        maximum = myMatrix[p][j];                   
        coordinates[p][0] = p;                     
        coordinates[p][1] = j;
       }
    }
 }

Answer 1

问题是你总是从第p次迭代的点p，p开始。相反，您可以使用两个变量

int top = coordinates[p][0] + 1;
int left = coordinates[p][1] + 1;

并使用它们编写循环，类似

for(int i = left; i < table_data.length; i++){  
    if(maximum <= myMatrix[i][top]){

（我可能已经颠倒了x和y，但这是个主意）。

然后你还需要修改封闭循环，它不能总是迭代。相反，检查顶部和左侧仍处于矩阵范围内的“while”循环将起作用。

Answer 2

试试这个：

public static void main(String[] a) throws Exception {
    int[][] aa = { { 4, 2, 2, 1, 0 }, { 2, 3, 2, 1, 0 }, { 2, 2, 1, 1, 1 }, { 1, 1, 2, 1, 0 }, { 1, 1, 0, 1, 0 },
            { 0, 0, 1, 0, 0 } };
    int[][] temp = aa;
    printArray(aa);
    System.out.println("---------------------");

    while ((temp = getArray(temp)) != null) {
        printArray(temp);

        System.out.println("---------------------");
    }

}

static int[][] getArray(int[][] aa) {
    int row = aa.length;
    int col = aa[0].length;
    if (row == 2 || col == 2) { // we can also try if (row == 1 || col == 1) to get the last array
        return null;
    }
    int[][] temp = new int[row - 1][col - 1];

    for (int i = 1; i < row; i++) {
        for (int j = 1; j < col; j++) {
            temp[i - 1][j - 1] = aa[i][j];
        }
    }
    return temp;
}

static void printArray(int aa[][]) {
    int row = aa.length;
    int col = aa[0].length;
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            System.out.print(aa[i][j] + " ");
        }
        System.out.println();
    }
}

Answer 3

首先，我不了解myMatrix和table_data之间的关系。我想你不需要两者。

此外，您将它们作为独立进行迭代，而我猜它们应该是相同的矩阵。

您提供的示例数据也没有相同的行数和列数。我不知道这是否有意，但如果是，你没有说明搜索停止的地方;在行数或列数。

无论如何，在这里考虑到这一点是一个有效的解决方案。

    int[][] myMatrix = {{4, 2, 2, 1, 0} ,
                        {2, 3, 2, 1, 0},
                        {2, 2, 1, 1, 1},  
                        {1, 1, 2, 1, 0}, 
                        {1, 1, 0, 1, 0}, 
                        {0, 0, 1, 0, 0}  };
    int coordinates[][] = new int[myMatrix.length][2];
    int maximum[] = new int[myMatrix.length];
    int m = Math.min(myMatrix.length, myMatrix[0].length);
    for(int p = 0; p < m; p++){  
        maximum[p] = myMatrix[p][p];
        coordinates[p][0] = p;
        coordinates[p][1] = p;
        for(int j = p; j < myMatrix[p].length; j++){ 
            if(maximum[p] <= myMatrix[p][j]){           
                maximum[p] = myMatrix[p][j];                   
                coordinates[p][0] = p;                     
                coordinates[p][1] = j;
            }
        }
        for(int i = p; i < myMatrix[p].length; i++){  
            if(maximum[p] <= myMatrix[i][p]){            
               maximum[p] = myMatrix[i][p];
               coordinates[p][0] = i;
               coordinates[p][1] = p;
           }
        }

如何在二维数组中找到子数组最顶行和最左列的最大值？

3 个答案: