Question

888. 公平的糖果交换

English Version

题目描述

爱丽丝和鲍勃拥有不同总数量的糖果。给你两个数组 aliceSizes 和 bobSizes ，aliceSizes[i] 是爱丽丝拥有的第 i 盒糖果中的糖果数量，bobSizes[j] 是鲍勃拥有的第 j 盒糖果中的糖果数量。

两人想要互相交换一盒糖果，这样在交换之后，他们就可以拥有相同总数量的糖果。一个人拥有的糖果总数量是他们每盒糖果数量的总和。

返回一个整数数组 answer，其中 answer[0] 是爱丽丝必须交换的糖果盒中的糖果的数目，answer[1] 是鲍勃必须交换的糖果盒中的糖果的数目。如果存在多个答案，你可以返回其中 任何一个 。题目测试用例保证存在与输入对应的答案。

 

示例 1：

输入：aliceSizes = [1,1], bobSizes = [2,2]
输出：[1,2]

示例 2：

输入：aliceSizes = [1,2], bobSizes = [2,3]
输出：[1,2]

示例 3：

输入：aliceSizes = [2], bobSizes = [1,3]
输出：[2,3]

示例 4：

输入：aliceSizes = [1,2,5], bobSizes = [2,4]
输出：[5,4]

 

提示：

• 1 <= aliceSizes.length, bobSizes.length <= 104
• 1 <= aliceSizes[i], bobSizes[j] <= 105
• 爱丽丝和鲍勃的糖果总数量不同。
• 题目数据保证对于给定的输入至少存在一个有效答案。

解法

方法一

class Solution:
  def fairCandySwap(self, aliceSizes: List[int], bobSizes: List[int]) -> List[int]:
    diff = (sum(aliceSizes) - sum(bobSizes)) >> 1
    s = set(bobSizes)
    for a in aliceSizes:
      target = a - diff
      if target in s:
        return [a, target]

class Solution {
  public int[] fairCandySwap(int[] aliceSizes, int[] bobSizes) {
    int s1 = 0, s2 = 0;
    Set<Integer> s = new HashSet<>();
    for (int a : aliceSizes) {
      s1 += a;
    }
    for (int b : bobSizes) {
      s.add(b);
      s2 += b;
    }
    int diff = (s1 - s2) >> 1;
    for (int a : aliceSizes) {
      int target = a - diff;
      if (s.contains(target)) {
        return new int[] {a, target};
      }
    }
    return null;
  }
}

class Solution {
public:
  vector<int> fairCandySwap(vector<int>& aliceSizes, vector<int>& bobSizes) {
    int s1 = accumulate(aliceSizes.begin(), aliceSizes.end(), 0);
    int s2 = accumulate(bobSizes.begin(), bobSizes.end(), 0);
    int diff = (s1 - s2) >> 1;
    unordered_set<int> s(bobSizes.begin(), bobSizes.end());
    vector<int> ans;
    for (int& a : aliceSizes) {
      int target = a - diff;
      if (s.count(target)) {
        ans = vector<int>{a, target};
        break;
      }
    }
    return ans;
  }
};

function fairCandySwap(aliceSizes: number[], bobSizes: number[]): number[] {
  let s1 = aliceSizes.reduce((a, c) => a + c, 0);
  let s2 = bobSizes.reduce((a, c) => a + c, 0);
  let diff = (s1 - s2) >> 1;
  for (let num of aliceSizes) {
    let target = num - diff;
    if (bobSizes.includes(target)) {
      return [num, target];
    }
  }
}