LeetCode 2122.还原原数组

Alice 有一个下标从 0 开始的数组 arr ，由 n 个正整数组成。她会选择一个任意的 正整数 k 并按下述方式创建两个下标从 0 开始的新整数数组 lower 和 higher ：

对每个满足 0 <= i < n 的下标 i ，lower[i] = arr[i] - k
对每个满足 0 <= i < n 的下标 i ，higher[i] = arr[i] + k
不幸地是，Alice 丢失了全部三个数组。但是，她记住了在数组 lower 和 higher 中出现的整数，但不知道每个整数属于哪个数组。请你帮助 Alice 还原原数组。

给你一个由 2n 个整数组成的整数数组 nums ，其中 恰好 n 个整数出现在 lower ，剩下的出现在 higher ，还原并返回 原数组 arr 。如果出现答案不唯一的情况，返回 任一 有效数组。

注意：生成的测试用例保证存在 至少一个 有效数组 arr 。

示例 1：

输入：nums = [2,10,6,4,8,12]
输出：[3,7,11]
解释：
如果 arr = [3,7,11] 且 k = 1 ，那么 lower = [2,6,10] 且 higher = [4,8,12] 。
组合 lower 和 higher 得到 [2,6,10,4,8,12] ，这是 nums 的一个排列。
另一个有效的数组是 arr = [5,7,9] 且 k = 3 。在这种情况下，lower = [2,4,6] 且 higher = [8,10,12] 。
示例 2：

输入：nums = [1,1,3,3]
输出：[2,2]
解释：
如果 arr = [2,2] 且 k = 1 ，那么 lower = [1,1] 且 higher = [3,3] 。
组合 lower 和 higher 得到 [1,1,3,3] ，这是 nums 的一个排列。
注意，数组不能是 [1,3] ，因为在这种情况下，获得 [1,1,3,3] 唯一可行的方案是 k = 0 。
这种方案是无效的，k 必须是一个正整数。
示例 3：

输入：nums = [5,435]
输出：[220]
解释：
唯一可行的组合是 arr = [220] 且 k = 215 。在这种情况下，lower = [5] 且 higher = [435] 。

提示：

2 * n == nums.length
1 <= n <= 1000
1 <= nums[i] <= 10${}^9$
生成的测试用例保证存在 至少一个 有效数组 arr

法一：我们可以枚举arr中所有元素的可能差值，然后对于每种差值k，遍历arr中的每个数字，然后看与该数字的差为k的元素是否存在（可以用哈希表来完成）：

class Solution {
public:vector<int> recoverArray(vector<int>& nums) {map<int, int> cnt;for (int i : nums) {++cnt[i];}int n = nums.size();// 最多可能有O(n)种unordered_set<int> seenK;// 双重循环实际O(n)时间for (auto it1 = cnt.begin(); it1 != cnt.end(); ++it1) {for (auto it2 = next(it1, 1); it2 != cnt.end(); ++it2) {int k = it2->first - it1->first;if ((k & 1) || (seenK.find(k) != seenK.end())) {continue;}seenK.insert(k);vector<int> ans;map<int, int> tmpCnt = cnt;auto it3 = tmpCnt.begin();// O(n)时间for (; it3 != tmpCnt.end(); ++it3) {bool notFound = false;while (it3->second) {// map查找，O(logn)时间if (tmpCnt[it3->first + k] == 0) {notFound = true;break;}ans.push_back(it3->first + k / 2);--it3->second;--tmpCnt[it3->first + k];}if (notFound) {break;}}if (it3 == tmpCnt.end()) {return ans;}}}return {};}
};

如果nums的长度为n，则此算法时间复杂度为O(n${}^2$logn)，上面的二重for循环看似是O(n${}^2$)的时间复杂度，实际由于第一层循环第一次取得是nums中的最小元素，它必定是lower[0]+k而来的，因此k必定能在二层循环的n次中取到合法的，因此该二重循环所用时间为O(n)，这份代码是不成熟的；空间复杂度为O(n)，seenK、cnt、tmpCnt都是O(n)大小。

法二：我们可以先对nums数组进行排序，然后遍历所有可能的k，对于从小到大第i个k，我们使用同向双指针，左指针l指向0，右指针r指向i，如果nums[l] + k < nums[r]，则右移r，直到找到当前k值下与l匹配的r，然后就可以右移l了：

class Solution {
public:vector<int> recoverArray(vector<int>& nums) {sort(nums.begin(), nums.end());int n = nums.size();// 遍历所有可能的kfor (int i = 1; i < n; ++i) {// 如果上一次遍历没有找到答案，且本次的k值与上次相同，则可跳过if (nums[i] == nums[i - 1]) {continue;}int k = nums[i] - nums[0];// k需要是一个整数if (k & 1) {continue;}int l = 0;int r = i; // nums已排序，i左边的元素与nums[0]相加一定小于kvector<int> ans(n / 2);int ansIdx = 0;// 已经匹配到对应值的r，右移l时需跳过vector<int> seen(n);while (r < n) {while (l < n && seen[l]) {++l;}// 找不到l对应的rif (nums[l] + k < nums[r]) {break;} else if (nums[l] + k > nums[r]) {++r;// 找到一个答案值} else {ans[ansIdx] = nums[l] + k / 2;++ansIdx;seen[r] = 1;++l;++r;}}if (ansIdx == n / 2) {return ans;}}return {};}
};

如果nums的长度为n，则此算法时间复杂度为O(n${}^2$)，空间复杂度为O(n)。