分配土地（HashMap（Integer， ArrayList＜OneField＞））

题目描述
从前有个村庄，村民们喜欢在各种田地上插上小旗子，旗子上标识了各种不同的数字。

某天集体村民决定将覆盖相同数字的最大矩阵形的土地分配给村里做出巨大贡献的村民，请问此次分配土地，做出贡献的村民种最大会分配多大面积?

输入描述
第一行输入 m 和 n，

m 代表村子的土地的长
n 代表土地的宽
第二行开始输入地图上的具体标识

输出描述
此次分配土地，做出贡献的村民种最大会分配多大面积

备注
旗子上的数字为1~500，土地边长不超过500
未插旗子的土地用0标识
用例1
输入
3 3
1 0 1
0 0 0
0 1 0
输出
9
说明
土地上的旗子为1，其坐标分别为(0,0)，(2,1)以及(0,2)，为了覆盖所有旗子，矩阵需要覆盖的横坐标为0和2，纵坐标为0和2，所以面积为9，即（2-0+1）*（2-0+1）= 9

用例2
输入
3 3
1 0 2
0 0 0
0 3 4
输出
1
说明
由于不存在成对的小旗子，故而返回1，即一块土地的面积。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Scanner;

class OneField{
    public int i;
    public int j;
    public int value;

    OneField(int i, int j, int value){
        this.i=i;
        this.j=j;
        this.value = value;
    }
}

public class Main{
    public static void main(String []args){
        // 计算矩阵右下角 横纵坐标最大值
        // 计算矩阵左下角 横纵坐标最小值

        Scanner in = new Scanner(System.in);
        int row = in.nextInt();
        int col = in.nextInt();
        // 存储输入的行列数
        int [][] field = new int[row][col];
        // 存储 输入的矩阵

        int [] symbol = new int [501];
        // 标志 每个数值的出现次数
        ArrayList<Integer> martixValue = new ArrayList<Integer>();
        // 记录找到的相同数字围起来的矩阵的面积，最后从中取出最大值
        // 若都没有相同数字 即 出现一个数字的次数 <=1 则没有矩阵 直接返回数字 1

        HashMap<Integer, ArrayList<OneField>> map = new HashMap<>();
        // 设计一个map key值为相同数字  ArrayList中存储一个OneField类型的链表
        // 把每个相同数字的元素包装成一个field对象存为一个链表
        // 通过key 来访问同一个数字 下 每个元素的 位置坐标 
        //取出位置坐标的最大最小值 计算矩阵大小 将结果存入记录所有矩阵面积的链表


        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                field[i][j] = in.nextInt();
                //System.out.print(field[i][j] + " ");
                if(field[i][j] > 0){
                    symbol[field[i][j]]++;
                    OneField oneField = new OneField(i,j,field[i][j]);

                    if(map.get(Integer.valueOf(field[i][j])) == null){
                        ArrayList<OneField> fields = new ArrayList<OneField>();
                        fields.add(oneField);
                        map.put(field[i][j],fields);
                    }
                    else{
                        ArrayList<OneField> fields = map.get(Integer.valueOf(field[i][j]));
                        fields.add(oneField);
                    }
                }
            }
            
        }

      /*for(int i=0;i<symbol.length;i++){
        if(symbol[i]>=1){
            // 至少出现了一次
            ArrayList<OneField> fields = map.get(i);
            if(fields!=null){
                for(OneField oneField:fields){
                    System.out.println(oneField.i + " " + oneField.j + " " + oneField.value);
                }
            }
        }
      }*/
      int moreThan2 = 0;

      for(int i=0;i<symbol.length;i++){
        if(symbol[i]>=2){
            moreThan2 = 1;
            // 至少出现了2次 才能构成矩阵
            ArrayList<OneField> fields = map.get(i);
            if(fields!=null){
                int rowvalue[] = new int[fields.size()];
                int colvalue[] = new int[fields.size()];
                int t = 0;
                for(OneField oneField:fields){
                    //System.out.println(oneField.i + " " + oneField.j + " " + oneField.value);
                    rowvalue[t] = oneField.i;
                    colvalue[t] = oneField.j;
                    t++;
                }
                int minrow = Arrays.stream(rowvalue).min().getAsInt();
                int mincol = Arrays.stream(colvalue).min().getAsInt();
                int maxrow = Arrays.stream(rowvalue).max().getAsInt();
                int maxcol = Arrays.stream(colvalue).max().getAsInt();
                //System.out.println("value: " + i + " " + minrow +" "+ mincol +" "+maxrow +" " + maxcol +" " );
                int square = (maxrow-minrow+1)*(maxcol-mincol+1);
                martixValue.add(square);
            }
        }
      }
      if(moreThan2 == 0){
        //System.out.println("相同数字的最大矩阵大小：" + 1);
        System.out.println(1);
      }
      else{
        int maxSquare = Collections.max(martixValue);
        //System.out.println("相同数字的最大矩阵大小： "+maxSquare);
        System.out.println(maxSquare);
      }
    }
}