3. 输入一个 n 行 m 列网格，找一个格子，使得它所在的行和列中所有格子的数之和最大Java

3. 输入一个 n 行 m 列网格，找一个格子，使得它所在的行和列中所有格子的数之和最大。如果答案不唯一，输出任意解即可。比如，在下面的例子中，最优解是(1,3)，即第一行和的三列的交点（行从上到下编号为 1—n，列从左到右编号为 1—m），所有 7 个数之和为 35。
   5 5 5 5
   1 1 5 1
   1 1 5 1
   1 1 5 1
   快要比赛的时候，小明想到了这样一个算法：
   首先找一行 r(1<=r<=n) 使得该行所有数之和最大，然后找一列 c(1<=c<=m) 使得该列所有数之和最大，最后直接输出(r,c)。如果有多个满足条件的 r，输出最小的 r。对于 c 同样处理。

显然，这个算法是错的，但它竟然通过了大部分测试数据！你能找出那些让这个错误算法得到正确结果的“弱”数据吗？

输入输出描述
输入
输入包含不超过 100 组数据。每组数据第一行为两个整数 n, m (1<=n<=500, 1<=m<=500)，即行数和列数。以下 n 行每行包含 m 个 1~100 的整数。输入的总大小不超过 2MB。

输出
对于每组数据，如果错误算法能得到正确结果，输出"Weak"，否则输出"Strong"。

编程要求
根据提示，在右侧编辑器补充代码，根据要求满足输入输出。

测试说明
平台会对你编写的代码进行测试：

样例输入

4 4
5 5 5 5
1 1 5 1
1 1 5 1
1 1 5 1
5 4
2 5 1 1
1 1 9 1
1 1 1 1
1 1 1 1
1 1 1 1
样例输出

Case 1: Weak
Case 2: Strong

public class T3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();


        int number[][] = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                number[i][j] = scanner.nextInt();
            }
        }


        if (solution1(number)[0] == solution2(number)[0] && solution1(number)[1] == solution2(number)[1]) {
            System.out.println("Week");
        } else {
            System.out.println("Strong");
        }

    }

    private static int[] solution2(int number[][]) {
        int maxCountRow = 0;
        int maxRow = 0;
        for (int i = 0; i < number.length; i++) {
            int count = 0;
            for (int j = 0; j < number[i].length; j++) {
                count += number[i][j];

            }
            if (count > maxCountRow) {
                maxCountRow = count;
                maxRow = i;
            }
        }
        int maxCountColumn = 0;
        int maxColumn = 0;
        for (int i = 0; i < number[0].length; i++) {
            int count = 0;
            for (int j = 0; j < number.length; j++) {
                count += number[j][i];
            }
            if (count > maxCountColumn) {
                maxCountColumn = count;
                maxColumn = i ;
            }
        }
        int Count = maxCountRow + maxCountColumn;

        int a[] = new int[3];
        a[0] = maxRow;
        a[1] = maxColumn;
        a[2] = Count;
       // System.out.println("Solution2:"+a[0]+" -----"+a[1]);
        return a;
    }

    private static int[] solution1(int number[][]) {
        int maxCount = 0;
        int maxRow = 0;
        int maxColumn = 0;

        for (int i = 0; i < number.length; i++) {
            int rowCount=0,count =0;
            for (int j = 0; j < number[i].length; j++) {
                rowCount += number[i][j];

            }
            for (int k = 0; k < number[i].length; k++) {
                int  colCount=0;
                for (int l = 0; l < number.length; l++) {
                    colCount += number[l][k];

                }
                count=rowCount+colCount-number[i][k];
                if (count > maxCount) {
                    maxCount = count;
                    maxRow = i;
                    maxColumn = k;
                }
            }


        }

        int a[] = new int[3];
        a[0] = maxRow;
        a[1] = maxColumn;
        a[2] = maxCount;
       // System.out.println("Solution1:"+a[0]+" -----"+a[1]);
        return a;
    }

}