leetcode2122还原原数组（困难，周赛）

自己没思路。。。
思路： 排序+枚举higher的第最小值
先排序，最小的元素一定是lower的第一个元素，然后枚举higher的第一个元素(j从1到n-1)并将它标记为true（长度为n的bool类型vis数组用于标记），这样k就确定了下来。除去这两个元素其余最小的就是lower的第二小值，然后用k计算得到higher的第二小（nums[j]+2*k）并将其标记为true（需要通过元素值找到下标值，这里用一个hash：元素值->vector的下标数组），重复这个过程，直到所有的元素都访问过。如果中间某一步计算得到的higher不存在直接break，higher的第一个元素遍历为下一个值。
难点：如果遍历完了，lower中的值都+k就得到了ans，那么，怎么确定lower都访问过哪些值呢？
解决：用vector来存

class Solution {
public:
    vector<int> recoverArray(vector<int>& nums) {

        int n = nums.size();
        sort(nums.begin(), nums.end());
        unordered_map<int, vector<int>> hash; 
        for (int i = 0; i < n; ++i) {
            hash[nums[i]].push_back(i);
        }
        vector<int> vis(n, 0);
        vector<int> ans;
        for (int i = 1; i < n; ++i) { //i枚举higher[0]
            if ((nums[i] == nums[i - 1]) || (nums[i] - nums[0]) % 2 != 0) continue; //优化
            fill(vis.begin(), vis.end(), 0);
            vis[i] = true;
            int k = (nums[i] - nums[0]) / 2; 
            vector<int> tmp{nums[0]};
            for (int j = 1; j < n; ++j) {
                if (vis[j]) continue;
                bool flag = false;
                if (hash.count(nums[j] + 2 * k)) {
                    tmp.push_back(nums[j]);
                    vis[j] = true;
                    for (auto& each : hash[nums[j] + 2 * k]) {
                        if (!vis[each]) {
                            vis[each] = true;
                            flag = true;
                            break;
                        }
                    }
                }else break;
                if (!flag) break;
            }
            if (tmp.size() == n / 2) {
                for (auto& each : tmp) {
                    ans.push_back(each + k);
                }
                break;
            }
        }
        return ans;
    }
};

优化：
1：j枚举higher[0]的时候，如果当前枚举的元素==前一个元素直接跳过。
2：j枚举higher[0]的时候，如果higher[0]-lower[0]为奇数，也直接跳过。