使用 java 8 IntStream 的沙漏總和

Question

我正在嘗試解決矩陣中沙漏的最大總和：

給定一個二維矩陣，我們的任務是找到沙漏的最大和。

沙漏由以下形式的 7 個單元格組成。

 ABC D EFG

我的實現出了點問題，我得到了奇怪的答案。 我應該得到 19，但它返回 36。

這是我的代碼：

static int hourglassSums(int[][] arr)
{
    return IntStream.range(0, 4).map(x -> {
        return IntStream.range(0, 4).map(y ->
                  arr[y][x] + arr[y][x + 1] + arr[y][x + 2] 
                  + arr[y + 1][x + 1] 
                  + arr[y + 2][x] + arr[y + 2][x + 1] + arr[y + 2][x + 2]
        ).sum();
    }).max().getAsInt();
}

public static void main(String[] args) 
{
    System.out.println("Max sum :: " + hourglassSums(new int[][] {
                    {1, 1, 1, 0, 0, 0},
                    {0, 1, 0, 0, 0, 0},
                    {1, 1, 1, 0, 0, 0},
                    {0, 0, 2, 4, 4, 0},
                    {0, 0, 0, 2, 0, 0},
                    {0, 0, 1, 2, 4, 0}
    }));
}

Answer 1

您已經在計算內部map調用中每個沙漏的總和。 因此，應用於內部IntStream的sum()終端操作沒有意義，因為它添加了多個IntStream的總和。

您的代碼實際上返回 38，這是以下沙漏的總和：

hour      hour
glass     glass
          sum

1 0 0
  0          2
1 0 0

0 0 0
  0         10
2 4 4

1 0 0        
  4          7
0 2 0

2 4 4 
  2         19
1 2 4
            --
            38

您可以通過查找內部IntStream的最大總和，然后找到外部IntStream的最大總和來解決此IntStream ：

static int hourglassSums(int[][] arr) {
      return IntStream.range(0, 4).map(x -> {
          return IntStream.range(0, 4).map(y ->
                  arr[y][x] + arr[y][x + 1] + arr[y][x + 2] 
                  + arr[y + 1][x + 1] 
                  + arr[y + 2][x] + arr[y + 2][x + 1] + arr[y + 2][x + 2]
          ).max().getAsInt(); // find the max hour glass sum of all the hour
                              // glasses starting at column x
      }).max().getAsInt(); // find the overall max hour glass sum
}

這導致

Max sum :: 19

更好的選擇是使用flatMap ：

static int hourglassSums(int[][] arr) {
      return IntStream.range(0, 4)
                      .flatMap(x -> IntStream.range(0, 4)
                                             .map(y -> arr[y][x] +
                                                       arr[y][x + 1] +
                                                       arr[y][x + 2] +
                                                       arr[y + 1][x + 1] +
                                                       arr[y + 2][x] +
                                                       arr[y + 2][x + 1] +
                                                       arr[y + 2][x + 2]))
                      .max()
                      .getAsInt();
}

通過這種方式，您可以創建所有沙漏總和的IntStream並找到該流的最大值。

Answer 2

問題是您要迭代 4 次 ( 0 - 3 )，但沙漏最寬處應該只有3數字。 您只需要迭代 3 次 (0 - 2)：

static int hourglassSums(int[][] arr) {
    return IntStream.range(0, 3).map(x -> {
        return IntStream.range(0, 3).map(y ->
                arr[y][x] + arr[y][x + 1] + arr[y][x + 2] 
                + arr[y + 1][x + 1] 
                + arr[y + 2][x] + arr[y + 2][x + 1] + arr[y + 2][x + 2]
        ).sum();
    }).max().getAsInt();
}

輸出：

19

這是來自沙漏：

2, 4, 4, 
   2, 
1, 2, 4

Answer 3

static int getMaxHour(Integer[][] arr) {
    return IntStream.range(0, 4).map(y -> {
        return IntStream.range(0, 4).map(x -> arr[y][x] + arr[y][x + 1] + 
           arr[y][x + 2] + arr[y + 1][x + 1]
            + arr[y + 2][x] + arr[y + 2][x + 1] + 
           arr[y + 2][x +2]).max().getAsInt();
      }).max().getAsInt();
  }