[双指针]还原原数组

题目描述

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 。

思路分析

• 题目中涉及两个因素（一个来自于lower数组，一个来自于higher数组）
• 可以向将两个因素同一侧进行遍历，但是两者相互制约，所以是双指针问题
• 排序后的arr[0]肯定是属于lower的元素
• 划分为子问题的方式：确定arr[0]对应的arr[i]是什么（即arr[0]+2*k==arr[i]），这里也就把k值确定了下来
• 定义low为当前的最小元素（肯定是未被遍历中最小的元素），通过arr[low]+2*k来找相应的high元素
• 没有被标记的最小的low肯定是属于lower的
• 最后通过判断vis的数组长度是否达到arr的长度判断是否在遍历过程中用到了所有的元素，从而最终得到问题的解。

源代码

class Solution {
public:
    int low,high;
    vector<int> v;
    vector<int> recoverArray(vector<int>& nums) {
        int n=nums.size();
        sort(nums.begin(),nums.end());
        if(n==2){
            v.push_back((nums[1]+nums[0])/2);
            return v;
        }
        map<int,int> vis;  //统计是否遍历过(节省了vector初始化的时间复杂度)
        int j;
        for(int i=1;i<n;i++){  //确定当前的k
            if(nums[i]==nums[0]||(nums[i]-nums[0])%2!=0) continue;
            vis.clear();
            v.clear();
            int low=1;
            vis[0]=1;vis[i]=1;     //i向后转移的过程中会受到j的影响
            int k=(nums[i]-nums[0])/2;
            v.push_back(nums[0]+k);

            while(low<n){
                while(vis[low]) low++;
                if(low==n) break;
                vis[low]=1;   //标记lower
                int m=low+1;
                for(;m<n;m++){ //找到对应的+2k元素
                    if(nums[m]==nums[low]+2*k&&vis[m]!=1){
                        v.push_back(nums[low]+k);
                        vis[m]=1; //标记higher
                        break;
                    }
                }
                if(m==n) break;
            }
            if(vis.size()==n+1) return v;
        }
    }
};