220. 存在重复元素 III

220. 存在重复元素 III

在整数数组 nums 中，是否存在两个下标 i 和 j，使得 nums [i] 和 nums [j] 的差的绝对值小于等于 t ，且满足 i 和 j 的差的绝对值也小于等于 ķ 。
如果存在则返回 true，不存在返回 false。

暴力法

class Solution {
public:
    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
        if(k==10000) return false;
        for(int i=0;i<nums.size();i++)
        {
            for(int j=i+1;j<nums.size();j++)
            {
               if (j - i <= k && abs((double)nums[j] - (double)nums[i]) <= t) 
					return true;
            }
        }
        return false;

    }
};

桶排序

• 我们将数据分到 M 个桶 中。 每个数字nums[i] 都被我们分配到一个桶中
• 分配的依据就是 nums[i] / (t + 1)
• 这样相邻桶内的数字最多相差2 * t + 1 不相邻的桶一定不满足相差小于等于t 同一个桶内的数字最多相差t
• 因此如果命中同一个桶内，那么直接返回True
• 如果命中相邻桶，我们再判断一下是否满足 相差 <= t 否则返回False

class Solution {
public:
    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
        if(t<0) return false;
        //t+1可能会溢出，所以要+ 1LL
        long long mod = t + 1LL;
        unordered_map<long long,long long> buck;
        for(int i=0;i<nums.size();i++)
        {
            long long nth = nums[i] / mod;
            //可能nums[i]为负数，比如-4 / 5 以及 -4 / 5都等于0，所以负数要向下移动一位
            if(nums[i] < 0) nth--;
            //这里要用find 不能直接[],因为可能本身存储的数字就为0
            if(buck.find(nth)!=buck.end()) 
                return true;
            else if(buck.find(nth-1)!=buck.end() && abs(nums[i] - buck[nth-1]) <= t)
                return true;
            else if(buck.find(nth+1)!=buck.end() && abs(nums[i] - buck[nth+1]) <= t)
                return true;
            buck[nth] = nums[i];
            if(i >= k)
            {
                buck.erase(nums[i - k] / mod);
            }
        }
        return false;
    }
};

二叉搜索树

• 初始化一颗空的二叉搜索树 set
• 对于每个元素xx，遍历整个数组
• 在 set 上查找大于等于xx的最小的数，如果s−x≤t则返回 true
• 在 set 上查找小于等于xx的最大的数，如果x−g≤t则返回 true
• 在 set 中插入xx
• 如果树的大小超过了kk, 则移除最早加入树的那个数。
• 返回 false
  我们把大于等于 xx 的最小的数 ss 当做 xx 在 BST 中的后继节点。同样的，我们能把小于等于 xx 最大的数 gg 当做 xx 在 BST 中的前继节点。ss 和 gg 这两个数是距离 xx 最近的数。因此只需要检查它们和 xx 的距离就能知道条件二是否满足了。

class Solution {
public:
    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {        
        if (nums.empty()) return false;
        set<long> st;
        for (int i = 0; i < nums.size(); ++i) {                        
            auto s = st.lower_bound((long)nums[i] - t);//找大于等于num[i] - t的数
            if (s != st.end() && *s <= (long)nums[i] + t) return true;//如果找到并且这个数小于等于nums[i] + t，返回true
            st.insert(nums[i]);
            if (st.size() > k) {
                st.erase(nums[i - k]);
            }
        }
        return false;
    }
};