Question

“找到矩阵中的最大元素，并从矩阵中删除包含该元素的所有行和列”。

我做了方法。在其中之一中，我找到了矩阵中最大的数字。在第二个中，我从矩阵中删除包含最大数字的行和列。但是，只有最大的数字是唯一的，它才能正常工作。如何删除所有包含最大数字的行和所有列？

private void deleteRowCol() {
    int[][] matrix = getMatrix();
    int max = matrix[0][0];
    for (int i = 0; i < matrix.length; i++) {
        for (int j = 0; j < matrix[0].length; j++) {
            if (max < matrix[i][j]) {
                max = matrix[i][j];
            }
        }
    }
    int[] m = findIdMax(matrix, max);
    int[][] outMatrix = new int[matrix.length - 1][matrix[0].length - 1];
    int r = 0;
    for (int i = 0; i < outMatrix.length; i++) {
        if (i > m[0] - 1) {
            r = 1;
        }
        int c = 0;
        for (int j = 0; j < outMatrix[0].length; j++) {
            if (j > m[1] - 1) {
                c = 1;
            }
            outMatrix[i][j] = matrix[i + r][j + c];
        }
    }
    System.out.println(" ");
    outputMatrix(outMatrix);
}

private int[] findIdMax(int[][] matrix, int max) {
    int[] id = {0, 0};
    for (int i = 0; i < matrix.length; i++) {
        for (int j = 0; j < matrix[0].length; j++) {
            if (max == matrix[i][j]) {
                id[0] = i;
                id[1] = j;
            }
        }
    }
    return id;
}

预期输出：用这个矩阵

  4  2  0 -3
  4 -1  4  1
  0  2 -4  3
 -4 -1 -4 -2

应该带

 -2  3
 -1 -2

Answer 1

我找不到您当前代码的修复程序。一个问题是，您始终假设使用int[][] outMatrix = new int[matrix.length - 1][matrix[0].length - 1];删除了1行和1列。如果我在您的代码周围放了一个循环，那么如果最大值位于矩阵中的1,2和1,4位置（应该只删除1行，但删除2列），则会失败。

因此，也许其他人可以仔细查看您的实现并看到直接的修正而无需进行太多更改。相反，我从头开始考虑用例，并尝试自己完成任务。我最终得到了以下代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

class Main{
  private Set<Integer> rowsToDelete,
                       columnsToDelete;

  public static void main(String[] a){
    Main program = new Main();

    int[][] matrix = program.getMatrix();
    System.out.println("Before:");
    program.prettyPrintMatrix(matrix);
    System.out.println();

    int[][] modifiedMatrix = program.deleteRowCol(matrix);
    System.out.println("After:");
    program.prettyPrintMatrix(modifiedMatrix);
  }

  private int[][] getMatrix(){
    // Test:
    return new int[][]{
      { 4, 2, 0,-3},
      { 4,-1, 4, 1},
      { 0, 2,-4, 3},
      {-4,-1,-4,-2}
    };
  }

  private int[][] deleteRowCol(int[][] matrix) {
    int max = findMax(matrix);
    determineCoordinatesMax(matrix, max);

    // Some debug prints:
    System.out.println("Maximum: "+max);
    System.out.println("Rows to delete: "+rowsToDelete);
    System.out.println("Columns to delete: "+columnsToDelete);
    System.out.println();

    int[][] modifiedMatrix = deleteRows(matrix);
    modifiedMatrix = deleteColumns(modifiedMatrix);

    return modifiedMatrix;
  }

  private int findMax(int[][] matrix){
    int max = matrix[0][0];
    for(int[] row : matrix){
      for(int value : row){
        if(value > max){
          max = value;
        }
      }
    }
    return max;
  }

  private void determineCoordinatesMax(int[][] matrix, int max) {
    rowsToDelete = new HashSet<>();
    columnsToDelete = new HashSet<>();

    for(int r=0; r<matrix.length; r++){
      for(int c=0; c<matrix[r].length; c++){
        if(matrix[r][c] == max){
          rowsToDelete.add(r);
          columnsToDelete.add(c);
        }
      }
    }
  }

  private int[][] deleteRows(int[][] matrix){
    int rowsToLeave = matrix.length - rowsToDelete.size();
    int[][] modifiedMatrix = new int[rowsToLeave][];
    int i = 0;
    for(int r=0; r<matrix.length; r++){
      if(!rowsToDelete.contains(r)){
        modifiedMatrix[i] = matrix[r];
        i++;
      }
    }
    return modifiedMatrix;
  }

  private int[][] deleteColumns(int[][] matrix){
    int columnsAlreadyDeleted = 0;
    for(int columnToDelete : columnsToDelete){
      // Delete the columns one by one:
      int[][] modifiedMatrix = new int[matrix.length][matrix[0].length - 1];
      for(int r=0; r<matrix.length; r++){
        int i=0;
        for(int c=0; c<matrix[r].length; c++){
          if(c != columnToDelete - columnsAlreadyDeleted){
            modifiedMatrix[r][i] = matrix[r][c];
            i++;
          }
        }
      }
      columnsAlreadyDeleted++;
      matrix = modifiedMatrix;
    }
    return matrix;
  }

  private void prettyPrintMatrix(int[][] matrix){
    for(int[] row : matrix){
      System.out.println(Arrays.toString(row));
    }
  }
}

删除列可能需要一些调整，因为我现在有三个嵌套循环（在要删除的列上循环；在矩阵行上进行内部循环；在矩阵列上进行内部循环）。但是它可以正常工作，并且可以按预期方式删除int[][]的行和列。

您可以在此处查看它的运行情况：Try it online.

从矩阵中删除行和列

1 个答案: