HackerRank：翻转矩阵

Question

Problem: https://www.hackerrank.com/challenges/flipping-the-matrix/problem

Sample Solution: https://www.hackerrank.com/rest/contests/master/challenges/flipping-the-matrix/hackers/aymanwizard/download_solution?primary=true

我一直难以理解这个问题的解决方案以及如何处理算法。

Answer 1

添加到 Adeniyi 的评论中，可以进一步简化。不需要我可以看到将矩阵的副本创建到数组中。

为了解释，通过将矩阵除以 2 来确定左上象限的大小。

Illustration of possible matrix values

请注意上图中的每个单元格，对于左上象限中的每个单元格，可以将 4 个值之一翻转到该单元格中，1) 当前值，2) 右上象限中的对应值，3)左下象限的对应值，或 4) 右下象限的值（需要行翻转和列翻转，但仍可以移动到左上象限）。

考虑到这一点，循环遍历左上象限中的每个单元格，确定可以翻转到该单元格中的 4 个可能值。在这 4 个值中，只需获取最大值并添加到运行总数中即可。

这里是更新的代码：

    int sum = 0;
    
    //Divide size by 2 to get quadrant size
    int quadSize = matrix.size()/2;


    //Now for each cell in the upper quadrant, get the max value that could be flipped into that cell
    //
    //Iterate all rows in quadrant
    for(int r = 0; r < quadSize; r++)
    {
      //Iterate all columns in quadrant
      for(int c = 0; c < quadSize; c++)
      {
          //Grab the 4 possible values that could wind up in this location of the upper quadrant
            int p1 = matrix.get(r).get((2*quadSize) - c - 1);
            int p2 = matrix.get(r).get(c);
            int p3 = matrix.get((2*quadSize) - r - 1).get(c);
            int p4 = matrix.get((2*quadSize) - r - 1).get((2*quadSize) - c - 1);

            //Get the highest value possible in this cell
            sum += Math.max(p1, Math.max(p2, Math.max(p3, p4)));
      }
    }

    return sum;

Answer 2

试试这个

public static int flippingMatrix(List<List<Integer>> matrix) {
// Write your code here
    int sum = 0;
    int n = matrix.size()/2;
    int[][] _matrix = new int[matrix.size()][matrix.size()];
    for(int i = 0; i < _matrix.length; i++)
    {
            for(int j = 0; j < _matrix.length; j++)
            {
                _matrix[i][j] = matrix.get(i).get(j);
            }
    }
    
    for(int i = 0; i < n; i++)
        {
          for(int j = 0; j < n; j++)
          {
              int num1 = _matrix[i][(2*n) - j - 1];
              int num2 = _matrix[i][j];
              int num3 = _matrix[(2*n) - i - 1][j];
              int num4 = _matrix[(2*n) - i - 1][(2*n) - j - 1];

              sum += Math.max(num1, Math.max(num2, Math.max(num3, num4)));
          }
        }
        return sum;

Answer 3

在 Java 中：

public static int flippingMatrix(List<List<Integer>> matrix) {
    
  int n = matrix.size() / 2;
  int sum = 0;
    
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      sum += Math.max(Math.max(matrix.get(i).get(j), 
                               matrix.get(i).get(2*n - j - 1)),
                      Math.max(matrix.get(2*n - i - 1).get(j), 
                            matrix.get(2*n - i - 1).get(2*n - j - 1)));
     }
  }

  return sum;

 }