Java - 如何解决这个二维数组沙漏？答案

【问题标题】：Java - How to Solve this 2D Array Hour Glass?Java - 如何解决这个二维数组沙漏？
【发布时间】：2016-09-18 17:19:05
【问题描述】：

我正在解决一个问题，我必须在数组中的所有沙漏中打印最大的总和。你可以找到问题的详细信息here-

我尝试了什么：

public class Solution {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int arr[][] = new int[6][6];
        for (int arr_i = 0; arr_i < 6; arr_i++) {
            for (int arr_j = 0; arr_j < 6; arr_j++) {
                arr[arr_i][arr_j] = in.nextInt();
            }
        }

        int sum = 0;
        int tmp_sum = 0;
        for (int arr_i = 0; arr_i < 4; arr_i++) {
            for (int arr_j = 0; arr_j < 4; arr_j++) {
                if (arr[arr_i][arr_j] > 0) {
                    sum = sum + (arr[arr_i][arr_j]) + (arr[arr_i][arr_j + 1]) + (arr[arr_i][arr_j + 2]);
                    sum = sum + (arr[arr_i + 1][arr_j + 1]);
                    sum = sum + (arr[arr_i + 2][arr_j]) + (arr[arr_i + 2][arr_j + 1]) + (arr[arr_i + 2][arr_j + 2]);
                    if (tmp_sum < sum) {
                        tmp_sum = sum;
                    }
                    sum = 0;
                }
            }
        }
        System.out.println(tmp_sum);
    }
}

输入：

1 1 1 0 0 0
0 1 0 0 0 0
1 1 1 0 0 0
0 9 2 -4 -4 0
0 0 0 -2 0 0
0 0 -1 -2 -4 0

输出：

预期输出：

截图：

我不知道我在哪里做错了。我不明白为什么预期的输出是13。根据问题中给出的描述，它应该是10。这是一个错误的问题还是我对此的理解是错误的？

【问题讨论】：

标签： java arrays multidimensional-array

【解决方案1】：

删除if (arr[arr_i][arr_j] > 0) 语句。它会阻止在第 1 行第 0 列找到答案，因为该单元格是 0。

对您的代码进行其他改进的评论：

如果最好的沙漏总和是-4 怎么办？您应该将tmp_sum 初始化为Integer.MIN_VALUE。并将其命名为maxSum，以便更好地描述其用途。
您不应该在循环之外定义sum。在第一次分配时声明它，然后您不必将其重置为0。
您的迭代器应该只是i 和j。这些是整数迭代器的标准名称，并保持代码...更简洁。
如果您喜欢较长的名称，请使用 row 和 col，因为它们代表的就是这个。
数组查找不需要括号。
为清楚起见，我对下面的代码进行了格式化，以在数组查找中显示沙漏形状。

Scanner in = new Scanner(System.in);
int arr[][] = new int[6][6];
for (int i = 0; i < 6; i++){
    for (int j = 0; j < 6; j++){
        arr[i][j] = in.nextInt();
    }
}

int maxSum = Integer.MIN_VALUE;
for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 4; j++) {
        int sum = arr[i    ][j] + arr[i    ][j + 1] + arr[i    ][j + 2]
                                + arr[i + 1][j + 1]
                + arr[i + 2][j] + arr[i + 2][j + 1] + arr[i + 2][j + 2];
        if (maxSum < sum) {
            maxSum = sum;
        }
    }
}
System.out.println(maxSum);

【讨论】：

感谢您的建议和回答...对我帮助很大。
@Stun_Gravy 因为<4 表示最大值为3，沙漏上升至+2，所以最大值为5，恰好是大小为6 的数组中的最大索引.不知道您所说的“未指定数组大小” 是什么意思，因为您无法在不指定大小的情况下分配数组。
@Stun_Gravy 我刚刚提交，它通过了所有 8 个测试用例，所以我不知道你在说什么。

【解决方案2】：

import java.io.*;
import java.util.Scanner;

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int low = -9,high = 5;
        int lh = low * high;
        int sum = 0, i, j;
        int max = 0;
        int a[][] = new int[6][6];
        for (i = 0; i < 6; i++) {
            for (j = 0; j < 6; j++) {
                a[i][j] = in.nextInt();
            }
        }

        for (i = 0; i < 4; i++) {
           for (j = 0; j < 4; j++) {
               sum = (a[i][j] + a[i][j+1] + a[i][j+2]); 
               sum = sum + a[i+1][j+1];
               sum = sum + (a[i+2][j] + a[i+2][j+1] + a[i+2][j+2]);

               if (sum > lh) lh = sum;
            }
        }
        System.out.print(lh);
    }
}

【讨论】：

【解决方案3】：

给你..

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int a[][] = new int[6][6];
    int max = 0;
    for (int i = 0; i < 6; i++) {
        for (int j = 0; j < 6; j++) {
            a[i][j] = in.nextInt();
        }
    }
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            int sum = a[i][j] + a[i][j + 1] + a[i][j + 2] + a[i + 1][j + 1]
                    + a[i + 2][j] + a[i + 2][j + 1] + a[i + 2][j + 2];
            if (sum > max || (i == 0 && j == 0)) {
                max = sum;
            }
        }
    }
    System.out.println(max);
}

【讨论】：

【解决方案4】：

这是我的解决方案。我在计算总和的代码周围包裹了一个 if 语句，以确保我们不会越界。

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int arr[][] = new int[6][6];
    int max = Integer.MIN_VALUE;
    int tempMax = 0;

    for(int i=0; i < 6; i++){
        for(int j=0; j < 6; j++){
            arr[i][j] = in.nextInt();
        }
    }

    for(int i=0; i < 6; i++){
        for(int j=0; j < 6; j++){
            if (i + 2 < 6 && j + 2 < 6) {
                tempMax += arr[i][j] + arr[i][j + 1] + arr[i][j + 2];
                tempMax += arr[i + 1][j + 1];
                tempMax += arr[i + 2][j] + arr[i + 2][j + 1] + arr[i + 2][j + 2];

                if (max < tempMax) {
                    max = tempMax;
                } 

                tempMax = 0;
            }           
        }
    }

    System.out.println(max);
}

【讨论】：

你不需要这一行：if (i + 2 < 6 && j + 2 < 6) ...沿 i 的迭代只能有 4 个完整的 3by3 数组。你的` for(int j=0; j for(int i=0; i < 6; i++)。语句应以 4 结尾。即 ` for (int i = 0; i

【解决方案5】：

这里是沙漏问题的简单易懂的 C# 等效代码。

class Class1
{
    static int[][] CreateHourGlassForIndex(int p, int q, int[][] arr)
    {
        int[][] hourGlass = new int[3][];

        int x = 0, y = 0;
        for (int i = p; i <= p + 2; i++)
        {
            hourGlass[x] = new int[3];
            int[] temp = new int[3];
            int k = 0;
            for (int j = q; j <= q + 2; j++)
            {
                temp[k] = arr[i][j];
                k++;
            }
            hourGlass[x] = temp;
            x++;
        }

        return hourGlass;
    }

    static int findSumOfEachHourGlass(int[][] arr)
    {
        int sum = 0;
        for (int i = 0; i < arr.Length; i++)
        {
            for (int j = 0; j < arr.Length; j++)
            {
                if (!((i == 1 && j == 0) || (i == 1 && j == 2)))
                    sum += arr[i][j];
            }

        }

        return sum;
    }

    static void Main(string[] args)
    {
        int[][] arr = new int[6][];
        for (int arr_i = 0; arr_i < 6; arr_i++)
        {
            string[] arr_temp = Console.ReadLine().Split(' ');
            arr[arr_i] = Array.ConvertAll(arr_temp, Int32.Parse);
        }

        int[] sum = new int[16];
        int k = 0;
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 4; j++)
            {
                int[][] hourGlass = CreateHourGlassForIndex(i, j, arr);
                sum[k] = findSumOfEachHourGlass(hourGlass);
                k++;
            }
        }
        //max in sum array
        Console.WriteLine(sum.Max());

    }
}

快乐编码。谢谢， Ankit Bajpai

【讨论】：

【解决方案6】：

你可以试试这个代码：
我认为这对于初学者来说很容易理解。

public class Solution {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int arr[][] = new int[6][6];
        for(int arr_i=0; arr_i < 6; arr_i++){
            for(int arr_j=0; arr_j < 6; arr_j++){
                arr[arr_i][arr_j] = in.nextInt();
            }
        }
        int sum = 0;
        int sum2 = 0;
        int sum3 = 0;
        int x = 0;
        int max = Integer.MIN_VALUE;
        for(int i = 0; i < 4; i++){
            for(int j = 0; j < 4; j++){
                for(int k = 0; k < 3; k++){
                    sum += arr[i][j+k]; //top elements of hour glass
                    sum2 += arr[i+2][j+k]; //bottom elements of hour glass
                    sum3 = arr[i+1][j+1]; //middle elements of hour glass
                    x = sum + sum2 + sum3; //add all elements of hour glass
                }
                if(max < x){
                    max  = x;
                }
                sum = 0; 
                sum2 = 0; 
                sum3 = 0;
                x = 0;
            }            
        }
        System.out.println(max);
    }
}

【讨论】：

你应该解释代码有什么问题，而不仅仅是发布普通代码。

【解决方案7】：

这是另一个简单的选择，希望对您有所帮助：

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int a[][] = new int[6][6];
        for(int i=0; i < 6; i++){
            for(int j=0; j < 6; j++){
                a[i][j] = in.nextInt();
            }
        }
        int hg = Integer.MIN_VALUE, sum;
        for(int i=0; i<4; i++){
            for(int j=0; j<4; j++){
               sum = 0;
               sum = sum + a[i][j] + a[i][j+1] + a[i][j+2];
               sum = sum + a[i+1][j+1];
               sum = sum + a[i+2][j] + a[i+2][j+1] + a[i+2][j+2];
               if(sum>hg)
                   hg = sum;
            }
        }
        System.out.println(hg);
        in.close();
    }
}

【讨论】：

【解决方案8】：

在 -(minus) 和零输出的情况下还有另一种选择，我们可以使用短路的 ser Treeset 来实现相同的。下面是相同的代码

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int arr[][] = new int[6][6];

        for(int i=0; i < 6; i++){
            for(int j=0; j < 6; j++){
                arr[i][j] = in.nextInt();
            }
        }

        int sum=0;int output=0;
        Set<Integer> set=new TreeSet<Integer>();

        for(int k=0;k<4;k++ )
        {
            for(int y=0;y<4;y++)
            {
                sum=arr[k][y]+arr[k][y+1]+arr[k][y+2]+arr[k+1][y+1]+arr[k+2][y]+arr[k+2][y+1]+arr[k+2][y+2];                                         set.add(sum);
            }
        }

        int p=0;

        for(int u:set)
        {
            p++;
            if(p==set.size())
            output=u;
        }

        System.out.println(output);
    }
}

【讨论】：

【解决方案9】：

用 PHP 解决，可能会有帮助。

<?php

$handle = fopen ("php://stdin","r");
$input = [];

while(!feof($handle))
{
   $temp = fgets($handle);
   $input[] = explode(" ",$temp);
}

$maxSum = PHP_INT_MIN;
for($i=0; $i<4; $i++)
{
    for($j=0; $j<4; $j++)
    {
        $sum = $input[$i][$j] + $input[$i][$j + 1] + $input[$i][$j + 2] 
                                    + $input[$i + 1][$j + 1] + 
                  $input[$i + 2][$j] + $input[$i + 2][$j + 1] + $input[$i + 2][$j + 2]; 

        if($sum > $maxSum)
        {
            $maxSum = $sum;
        }
    }
}
echo $maxSum;

?>

【讨论】：

【解决方案10】：

通过所有测试用例

import java.io.*;
import java.util.*;

public class Solution {

public static void main(String[] args) {
    Scanner read = new Scanner(System.in);
    int rowSize = 6;
    int colSize = 6;
    int[][] array = new int[rowSize][colSize];
    for(int row = 0; row < rowSize; row++) {
        for(int col = 0; col < colSize; col++) {
            array[row][col] = read.nextInt();
        }
    }
    read.close();
    int max = Integer.MIN_VALUE;
    for(int row = 0; row < 4; row++) {
        for(int col = 0; col < 4; col++) {
            int sum = calculateHourglassSum(array, row, col);
            if(sum > max) {
                max = sum;
            }
        }
    }
    System.out.println(max);
}

private static int calculateHourglassSum(int[][] array, int rowIndex, int colIndex) {
    int sum = 0;
    for(int row = rowIndex; row < rowIndex + 3; row++) {
        for(int col = colIndex; col < colIndex + 3; col++) {
            if(row == rowIndex + 1 && col != colIndex + 1) {
                continue;
            }
            sum += array[row][col];
        }
    }
    return sum;
}
}

【讨论】：

【解决方案11】：

function galssSum(array) {
  let maxGlass = 0;
  if (array[0].length == 3) {
    maxGlass = 1;
  } else if (array[0].length > 3) {
    maxGlass = array.length - 2;
  }

  let maxValue = -100000;
  for (let i = 0; i < maxGlass; i++) {
    for (let j = 0; j < maxGlass; j++) {
      let a = array[i][j] + array[i][j + 1] + array[i][j + 2];
      let b = array[i + 1][j + 1];
      let c = array[i + 2][j] + array[i + 2][j + 1] + array[i + 2][j + 2];

      let sum = a + b + c;

      if (maxValue<sum) {
        maxValue = sum;
      }
    }
  }

  return maxValue;
}

console.log(galssSum([[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]]));

【讨论】：

【解决方案12】：

int hourglassSum(vector<vector<int>> vec) {

    int res = 0;
    int size = ((vec[0].size())-2) * ((vec.size())-2);
    //cout<<size<<endl;
    vector<int> res_vec(size);
    int j = 0;
    int itr =0 ;
    int cnt = 0;
    int mid = 0;
    int l =0;
    while((l+2) < vec.size())
    {
while((j+2) < vec.size())
{
        for(int i =j ;i<j+3; i+=2)
        {
            //cout<<i<<" :";
            for(int k=l;k<l+3;k++)
            {
                //cout<<k<<" ";
                res_vec[itr] += vec[i][k];
            }
            //cout<<endl;
        }
        res_vec[itr] += vec[j+1][l+1];
        //cout<<endl;
itr++;
        j++;
}
l++;
j=0;
    }

    int max=res_vec[0];
for(int i =1;i<res_vec.size();i++)
{
if(max < res_vec[i])
{
    max = res_vec[i];
}
    //cout<<res_vec[i]<< " ";
}
res = max;
//cout<<endl;
    return res;
}

【讨论】：

【解决方案13】：

// Complete the hourglassSum function below.
static int hourglassSum(int[][] arr) {
    int max = Integer.MIN_VALUE;
    for (int i = 0; i < arr.length - 2; i++) {
        for (int j = 0; j < arr.length - 2; j++) {
            int hourGlassSum = (arr[i][j] + arr[i][j + 1] + arr[i][j + 2])
                    + (arr[i + 1][j + 1])
                    + (arr[i + 2][j] + arr[i + 2][j + 1] + arr[i + 2][j + 2]);
            max = Math.max(hourGlassSum,max);
        }

    }
    return max;
}

【讨论】：