Leetcode-Day20(合并相似的物品)

题目：

给你两个二维整数数组 items1 和 items2 ，表示两个物品集合。每个数组 items 有以下特质：

• items[i] = [valuei, weighti] 其中 valuei 表示第 i 件物品的 价值 ，weighti 表示第 i 件物品的 重量 。
• items 中每件物品的价值都是 唯一的 。

请你返回一个二维数组 ret，其中 ret[i] = [valuei, weighti]， weighti 是所有价值为 valuei 物品的 重量之和 。

注意：ret 应该按价值 升序 排序后返回。

示例 1：

输入：items1 = [[1,1],[4,5],[3,8]], items2 = [[3,1],[1,5]]
输出：[[1,6],[3,9],[4,5]]
解释：
value = 1 的物品在 items1 中 weight = 1 ，在 items2 中 weight = 5 ，总重量为 1 + 5 = 6 。
value = 3 的物品再 items1 中 weight = 8 ，在 items2 中 weight = 1 ，总重量为 8 + 1 = 9 。
value = 4 的物品在 items1 中 weight = 5 ，总重量为 5 。
所以，我们返回 [[1,6],[3,9],[4,5]] 。

示例 2：

输入：items1 = [[1,1],[3,2],[2,3]], items2 = [[2,1],[3,2],[1,3]]
输出：[[1,4],[2,4],[3,4]]
解释：
value = 1 的物品在 items1 中 weight = 1 ，在 items2 中 weight = 3 ，总重量为 1 + 3 = 4 。
value = 2 的物品在 items1 中 weight = 3 ，在 items2 中 weight = 1 ，总重量为 3 + 1 = 4 。
value = 3 的物品在 items1 中 weight = 2 ，在 items2 中 weight = 2 ，总重量为 2 + 2 = 4 。
所以，我们返回 [[1,4],[2,4],[3,4]] 。

解题思路： 外层循环先遍历第一个数组，内层循环遍历第二个数组，依次找有没有相同价值的物品，如果有，将重量相加再加入到集合中，反之将物品价值和重量加入到集合中。再从第二个数组开始遍历，再遍历第一个数组，跟之前一样，主要是为了第二个数组有的物品价值而第一个数组没有的物品价值的情况。这样集合中肯定会存在相同的数组，所以需要去掉重复值，然后输出要求是按价值升序排序的，所以还需要对集合进行排序。

代码如下：

import java.util.*;
import java.util.stream.Collectors;

public class Leetcode {
    public static void main(String[] args) {
        int[][] items1 = new int[][]{{1, 3}, {2, 2}};
        int[][] items2 = new int[][]{{7, 1}, {2, 2},{1, 4}};
        System.out.println(mergeSimilarItems(items1, items2));
    }
    
    public static List<List<Integer>> mergeSimilarItems(int[][] items1, int[][] items2) {
        int n = items1.length;                                      //第一个二维数组的长度
        int m = items2.length;                                      //第二个二维数组的长度
        List<List<Integer>> list = new ArrayList<List<Integer>>();  //list用来存储物品的重量之和
        boolean flag = false;                                       //标识是否有相同物品的价值，默认为没有
        //外层循环从第一个二维数组遍历价值
        for (int i = 0; i < n; i++) {
            int[][] temp = new int[1][2];                           //暂存物品的价值和重量
            List<Integer> columnList = new ArrayList<Integer>();    //存放物品一维价值和重量的集合
            flag = false;                                           //每一轮循环标志位重置
            //内层循环遍历第二个二维数组的价值
            for (int j = 0; j < items2.length; j++) {
                if (items1[i][0] == items2[j][0]) {                 //两个二维数组有相同的价值物品
                    temp[0][0] = items1[i][0];
                    temp[0][1] = items1[i][1] + items2[j][1];
                    columnList.add(temp[0][0]);
                    columnList.add(temp[0][1]);
                    flag = true;
                }
            }
            //检查是否有相同物品的价值，如果一轮内层循环结束还是false，则没有相同物品的价值
            if (!flag) {
                temp[0][0] = items1[i][0];
                temp[0][1] = items1[i][1];
                columnList.add(temp[0][0]);
                columnList.add(temp[0][1]);
            }
            list.add(columnList);                                   //将一维数组集合加入到二维集合中
        }

        //外层循环从第二个二维数组遍历价值，跟上面的一样，主要是为了避免遍历掉第二个数组有的价值而第一个数组没有的价值的物品
        for (int k = 0; k < m; k++) {
            int[][] temp1 = new int[1][2];
            List<Integer> columnList1 = new ArrayList<Integer>();
            boolean flag1 = false;
            for (int j = 0; j < items1.length; j++) {
                if (items2[k][0] == items1[j][0]) {
                    temp1[0][0] = items2[k][0];
                    temp1[0][1] = items1[j][1] + items2[k][1];
                    columnList1.add(temp1[0][0]);
                    columnList1.add(temp1[0][1]);
                    flag1 = true;
                }
            }
            if (!flag1) {
                temp1[0][0] = items2[k][0];
                temp1[0][1] = items2[k][1];
                columnList1.add(temp1[0][0]);
                columnList1.add(temp1[0][1]);
            }
            list.add(columnList1);
        }
        //二维List集合去掉重复元素
        List<List<Integer>> ret = list.stream().distinct().collect(Collectors.toList());
        //从小到大的排序
        ret.sort(Comparator.comparingInt(o -> o.get(0)));
        return ret;
    }
}

运行结果：不是很理想，大量的时间浪费在遍历和排序上了，后续看能不能优化。