5860. 从双倍数组中还原原数组

一个整数数组 original 可以转变成一个双倍数组 changed ，转变方式为将 original 中每个元素 值乘以 2 加入数组中，然后将所有元素 随机打乱 。

给你一个数组 changed ，如果 change 是双倍数组，那么请你返回 original数组，否则请返回空数组。original 的元素可以以任意顺序返回。

示例 1：

输入：changed = [1,3,4,2,6,8]
输出：[1,3,4]
解释：一个可能的 original 数组为 [1,3,4] :
- 将 1 乘以 2 ，得到 1 * 2 = 2 。
- 将 3 乘以 2 ，得到 3 * 2 = 6 。
- 将 4 乘以 2 ，得到 4 * 2 = 8 。
其他可能的原数组方案为 [4,3,1] 或者 [3,1,4] 。

示例 2：

输入：changed = [6,3,0,1]
输出：[]
解释：changed 不是一个双倍数组。

示例 3：

输入：changed = [1]
输出：[]
解释：changed 不是一个双倍数组。

提示：

1 <= changed.length <= 10^5
0 <= changed[i] <= 10^5

**1.使用map实现，很麻烦**
class Solution {
        public int[] findOriginalArray(int[] changed) {
            int n = changed.length;
            Arrays.sort(changed);
            if ((n & 1) == 1) return new int[]{};
            int mid = n >> 1;
            int[] ans = new int[mid];
            int idx = 0;
            HashMap<Integer, Integer> map = new HashMap<>();
            for (int num : changed) {
                map.put(num, map.getOrDefault(num, 0) + 1);
            }
            for (int num : changed) {
                if (map.containsKey(num) && map.containsKey(num * 2)) {
                    int k = map.get(num);
                    if (idx == mid) return new int[]{};
                    ans[idx++] = num;
                    if (k == 1) map.remove(num);
                    else map.put(num, k - 1);
                    if(!map.containsKey(num * 2)) return new int[]{};
                    int t = map.get(num * 2);
                    if (t == 1) map.remove(num * 2);
                    else map.put(num * 2, t - 1);
                }
            }
            
            return map.size() == 0 ? ans : new int[]{};
        }
    }
**2.使用queue实现，简单**
class Solution {
        public int[] findOriginalArray(int[] changed) {
            Arrays.sort(changed);
            int n = changed.length;
            int m = n >> 1;
            int[] ans = new int[m];
            int idx = 0;
            Queue<Integer> q = new LinkedList<>();
            for (int num : changed) {
                if (!q.isEmpty() && num == q.peek()) {
                    q.poll();
                } else {
                    if (idx == m) return new int[]{};
                    ans[idx++] = num;
                    q.offer(num * 2);
                }
            }
            return q.isEmpty() ? ans : new int[]{};
        }
    }
    //通过stream()简化代码
    class Solution {
        public int[] findOriginalArray(int[] changed) {
            Arrays.sort(changed);
            ArrayList<Integer> ans = new ArrayList<>();
            Queue<Integer> q = new LinkedList<>();
            for (int num : changed) {
                if (!q.isEmpty() && num == q.peek()) {
                    q.poll();
                } else {
                    ans.add(num);
                    q.offer(num * 2);
                }
            }
            return q.isEmpty() ? ans.stream().mapToInt(Integer::intValue).toArray() : new int[]{};
        }
    }

5860. 从双倍数组中还原原数组

5860. 从双倍数组中还原原数组

相关推荐