2363.合并相似的物品

【LetMeFly】2363.合并相似的物品：两种方法（哈希 / 排序+双指针）

力扣题目链接：https://leetcode.cn/problems/merge-similar-items/

给你两个二维整数数组 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]] 。

示例 3：

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

 

提示：

• 1 <= items1.length, items2.length <= 1000
• items1[i].length == items2[i].length == 2
• 1 <= valuei, weighti <= 1000
• items1 中每个 valuei 都是 唯一的 。
• items2 中每个 valuei 都是 唯一的 。

方法一：哈希表

使用哈希表（有序哈希表 或 无序哈希表加排序），以每个物品的value为key，累加相同的key的weight，最终将哈希表转化成列表/数组即可

• 时间复杂度$O((len(items1) + len(items2))\times \log (len(items1) + len(items2)))$
• 空间复杂度$O(len(items1) + len(items2))$

AC代码

C++

class Solution {
public:
    vector<vector<int>> mergeSimilarItems(vector<vector<int>>& items1, vector<vector<int>>& items2) {
        map<int, int> ma;
        for (auto& v : items1) {
            ma[v[0]] += v[1];
        }
        for (auto& v : items2) {
            ma[v[0]] += v[1];
        }
        vector<vector<int>> ans;
        for (auto& v : ma) {
            ans.push_back({v.first, v.second});
        }
        return ans;
    }
};

Python

# from collections import defaultdict
# from typing import List


class Solution:
    def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
        ma = defaultdict(int)
        for a, b in items1:
            ma[a] += b
        for a, b in items2:
            ma[a] += b
        return sorted([[a, b] for a, b in ma.items()])

方法二：排序 + 双指针

方法一中使用现成的哈希表使得代码写起来很简单，但是需要$O(len(items1) + len(items2))$的空间复杂度

不难发现，题目中只需要合并两个数组为一个数组，因此我们只需要对两个数组分别排序，然后使用双指针指向这两个数组，比较这两个指针所指元素的value的大小，如果两数组所指的value相同，则累加后放入答案中；否则将value较小的放入答案中。

每放入一个元素到答案中，当前数组的指针就后移。直到两个数组的指针都指向了数组的末尾为止。

• 时间复杂度$O(len(items1)\times\log len(items1) + len(items2)\times\log len(items2))$
• 空间复杂度$O(1)$，返回的答案不计入算法的空间复杂度

AC代码

C++

class Solution {
public:
    vector<vector<int>> mergeSimilarItems(vector<vector<int>>& items1, vector<vector<int>>& items2) {
        sort(items1.begin(), items1.end());
        sort(items2.begin(), items2.end());
        vector<vector<int>> ans;
        int l1 = 0, l2 = 0;
        while (l1 < items1.size() && l2 < items2.size()) {
            if (items1[l1][0] == items2[l2][0]) {
                ans.push_back({items1[l1][0], items1[l1][1] + items2[l2][1]});
                l1++, l2++;
            }
            else if (items1[l1][0] < items2[l2][0]) {
                ans.push_back(items1[l1]);
                l1++;
            }
            else {
                ans.push_back(items2[l2]);
                l2++;
            }
        }
        while (l1 < items1.size()) {
            ans.push_back(items1[l1++]);
        }
        while (l2 < items2.size()) {
            ans.push_back(items2[l2++]);
        }
        return ans;
    }
};

Python

# from typing import List


class Solution:
    def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
        items1.sort()
        items2.sort()
        ans = []
        l1, l2 = 0, 0
        while l1 < len(items1) and l2 < len(items2):
            if items1[l1][0] == items2[l2][0]:
                ans.append([items1[l1][0], items1[l1][1] + items2[l2][1]])
                l1 += 1
                l2 += 1
            elif items1[l1][0] < items2[l2][0]:
                ans.append(items1[l1])
                l1 += 1
            else:
                ans.append(items2[l2])
                l2 += 1
        while l1 < len(items1):
            ans.append(items1[l1])
            l1 += 1
        while l2 < len(items2):
            ans.append(items2[l2])
            l2 += 1
        return ans

同步发文于CSDN，原创不易，转载请附上原文链接哦~
Tisfy：https://letmefly.blog.csdn.net/article/details/129257424