QD2022Q4

 /***********************************************************
     *
     * 题目描述
     * [最多等和不相交连续子序列 Q]
     * 给一个二维数组nums，对于每一个元素num，找出距离最近的且值相等的元素，输出横纵坐标差值的绝对值之和，如果没有等值元素，则输出-1。
     * 例如:
     * 输入数组Qnums为
     * 9 3 5 4 2
     * 21
     * 2 57 8 3
     * 32 5 4 2 4
     * 对于 num[e][e] = 0，不存在相等的值。
     * 对于 num[e][1] = 3，存在一个相等的值，最近的坐标为 num[1][4]，最小距离为4.
     * 对于 num[e][2] = 5，存在两个相等的值，最近的坐标为 num[1][1]，故最小距离为2
     * 对于 num[1][1] = 5，存在两个相等的值，最近的坐标为 num[2][1]，故最小距离为1.
     * 1-1 42 33
     * 2 1 1-1 -14
     * 311 2 3 2
     * 示例1 输入输出示例仅供调试，后台判题数据一般不包含示例
     *
     *
     * 输入：
     * 3
     * 5
     * 0 3 5 4 2
     * 2 5 7 8 3
     * 2 5 4 2 4
     *
     * 输出：
     * [[-1, 4, 2, 3, 3], [1, 1, -1, -1, 4], [1, 1, 2, 3, 2]]
     *
     *
     * *********************************************************/
    public static void Test03041101() {

        /*****************************************************************
         * 1.创建二维数组，将数据添加进对应的位置;
         * 2.遍历二维数组(i,j)，判断每个数字对应的坐标位置（key,value--key不重复，重复则更新value）;
         * 3.遍历二维数组(i,j), 获取每个数字下的坐标位置集合M，遍历集合输出最小距离(计算方式：坐标对应行列相减);
         * 4.将每个数字对应的最小距离存入集合A，待行遍历完毕之后，将整行的最短距离集合添加进新的集合B;
         * 5.输出最终集合B!!!
         * ***************************************************************/

        // 处理输入
        Scanner in = new Scanner(System.in);

        int n = in.nextInt();
        int m = in.nextInt();

        int[][] matrix = new int[n][m];//定义二维数组

        Map<Integer, List<int[]>> num_map = new HashMap<>();//存储数字及其坐标
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                int num = in.nextInt();
                matrix[i][j] = num;
                //将坐标转化为数组
                int[] pos = new int[]{i, j};
                List<int[]> tempList;
                if (num_map.containsKey(num)) {
                    tempList = num_map.get(num);
                } else {
                    tempList = new ArrayList<>();
                }
                tempList.add(pos);
                num_map.put(num, tempList);
            }
        }

        List<List<Integer>> resList = new ArrayList<>();
//        循环遍历行
        for (int i = 0; i < n; i++) {
            List<Integer> temp_list = new ArrayList<>();
            //循环遍历列
            for (int j = 0; j < m; j++) {
                int num = matrix[i][j];//获取对应坐标下的数字
                List<int[]> pos_list = num_map.get(num);//获取数字对应的坐标集合
                //无相等值
                if (pos_list.size() == 1) {//只有其本身时候返回-1
                    temp_list.add(-1);
                    continue;
                }

                int min_distance = Integer.MAX_VALUE;


                for (int k = 0; k < pos_list.size(); k++) {//遍历数字对应的坐标集合，计算最小移动距离
                    if (num==3){
                        System.out.println("shit!!!（"+i+","+j+")");
                    }
                    int[] pos = pos_list.get(k);
                    int distance = Math.abs(pos[0] - i) + Math.abs(pos[1] - j);//i-行；j-列；
                    if (num==3){
                        System.out.println("距离=>"+distance);
                    }
                    //距离为0则跳过
                    if (distance == 0) {
                        continue;
                    }
                    min_distance = Math.min(min_distance, distance);
                }

                temp_list.add(min_distance);//以行数为单位，讲距离从左至右侧依次添加进集合
            }
            resList.add(temp_list);//以行数为单位，讲距离从左至右侧依次添加进集合
        }

        System.out.println(resList);
    }