从矩阵中删除行和列

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.