力扣-888公平的糖果交换(Java)

888.公平的糖果交换

爱丽丝和鲍勃拥有不同总数量的糖果。给你两个数组 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 使用HashSet 降低执行时间

执行用时分布8ms击败97.86%

class Solution {
    public int[] fairCandySwap(int[] aliceSizes, int[] bobSizes) {
        int aSum = 0, bSum = 0;
        Set<Integer> setB = new HashSet<>();
        int totalSum = 0;
        
        for (int size : aliceSizes) {
            aSum += size;
        }
        
        for (int size : bobSizes) {
            bSum += size;
            setB.add(size);
        }
        
        totalSum = (aSum + bSum) / 2;
        
        for (int size : aliceSizes) {
            int target = totalSum - (aSum - size);
            if (setB.contains(target)) {
                return new int[]{size, target};
            }
        }
        
        return new int[2];
    }
}

方法2 正常循环嵌套  降低消耗内存

消耗内存分布 44.48MB击败96.09%

class Solution {
    public int[] fairCandySwap(int[] aliceSizes, int[] bobSizes) {
        int aSum=0,bSum=0,count;
        int [] arr = new int[2];
        for(int i =0;i<aliceSizes.length;i++){
            aSum+=aliceSizes[i];
        }
        for(int j = 0; j<bobSizes.length;j++){
            bSum+=bobSizes[j];
        }
        count=(aSum+bSum)/2;
         for(int i =0;i<aliceSizes.length;i++){
            for(int j = 0; j<bobSizes.length;j++){
                if(aSum-aliceSizes[i]+bobSizes[j]==count){
                    arr[0]=aliceSizes[i];
                    arr[1]=bobSizes[j];
                    break;
                }
            }
    }
    return arr;
}
}