Question

2363. 合并相似的物品

English Version

题目描述

给你两个二维整数数组 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 都是 唯一的 。

解法

方法一：哈希表或数组

我们可以用哈希表或数组 cnt 统计 items1 和 items2 中每个物品的总重量，然后从小到大遍历价值，将每个价值以及对应的总重量加入结果数组即可。

时间复杂度 $O(n + m)$，空间复杂度 $O(n + m)$。其中 $n$ 和 $m$ 分别是 items1 和 items2 的长度。

class Solution:
  def mergeSimilarItems(
    self, items1: List[List[int]], items2: List[List[int]]
  ) -> List[List[int]]:
    cnt = Counter()
    for v, w in chain(items1, items2):
      cnt[v] += w
    return sorted(cnt.items())

class Solution {
  public List<List<Integer>> mergeSimilarItems(int[][] items1, int[][] items2) {
    int[] cnt = new int[1010];
    for (var x : items1) {
      cnt[x[0]] += x[1];
    }
    for (var x : items2) {
      cnt[x[0]] += x[1];
    }
    List<List<Integer>> ans = new ArrayList<>();
    for (int i = 0; i < cnt.length; ++i) {
      if (cnt[i] > 0) {
        ans.add(List.of(i, cnt[i]));
      }
    }
    return ans;
  }
}

class Solution {
public:
  vector<vector<int>> mergeSimilarItems(vector<vector<int>>& items1, vector<vector<int>>& items2) {
    int cnt[1010]{};
    for (auto& x : items1) {
      cnt[x[0]] += x[1];
    }
    for (auto& x : items2) {
      cnt[x[0]] += x[1];
    }
    vector<vector<int>> ans;
    for (int i = 0; i < 1010; ++i) {
      if (cnt[i]) {
        ans.push_back({i, cnt[i]});
      }
    }
    return ans;
  }
};

func mergeSimilarItems(items1 [][]int, items2 [][]int) (ans [][]int) {
  cnt := [1010]int{}
  for _, x := range items1 {
    cnt[x[0]] += x[1]
  }
  for _, x := range items2 {
    cnt[x[0]] += x[1]
  }
  for i, x := range cnt {
    if x > 0 {
      ans = append(ans, []int{i, x})
    }
  }
  return
}

function mergeSimilarItems(items1: number[][], items2: number[][]): number[][] {
  const count = new Array(1001).fill(0);
  for (const [v, w] of items1) {
    count[v] += w;
  }
  for (const [v, w] of items2) {
    count[v] += w;
  }
  return [...count.entries()].filter(v => v[1] !== 0);
}

impl Solution {
  pub fn merge_similar_items(items1: Vec<Vec<i32>>, items2: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
    let mut count = [0; 1001];
    for item in items1.iter() {
      count[item[0] as usize] += item[1];
    }
    for item in items2.iter() {
      count[item[0] as usize] += item[1];
    }
    count
      .iter()
      .enumerate()
      .filter_map(|(i, &v)| {
        if v == 0 {
          return None;
        }
        Some(vec![i as i32, v])
      })
      .collect()
  }
}

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int** mergeSimilarItems(int** items1, int items1Size, int* items1ColSize, int** items2, int items2Size,
  int* items2ColSize, int* returnSize, int** returnColumnSizes) {
  int count[1001] = {0};
  for (int i = 0; i < items1Size; i++) {
    count[items1[i][0]] += items1[i][1];
  }
  for (int i = 0; i < items2Size; i++) {
    count[items2[i][0]] += items2[i][1];
  }
  int** ans = malloc(sizeof(int*) * (items1Size + items2Size));
  *returnColumnSizes = malloc(sizeof(int) * (items1Size + items2Size));
  int size = 0;
  for (int i = 0; i < 1001; i++) {
    if (count[i]) {
      ans[size] = malloc(sizeof(int) * 2);
      ans[size][0] = i;
      ans[size][1] = count[i];
      (*returnColumnSizes)[size] = 2;
      size++;
    }
  }
  *returnSize = size;
  return ans;
}