leetcode 220: Contains Duplicate III

Use set to find numbers with time complexity of O(n*logk). Learned this from http://www.cnblogs.com/easonliu/p/4544073.html.

class Solution {
public:
    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
        set<int> window;
        int n=nums.size();
        for(int i=0;i<n;i++)
        {
            if(window.size()>k)
                window.erase(window.find(nums[i-k-1]));
            set<int>::iterator it;
            it=window.lower_bound(nums[i]-t);
            if(it!=window.end()&&abs(*it-nums[i])<=t)
                return true;
            window.insert(nums[i]);
        }
        return false;
    }
};

Use unordered map to implement the bucket sort can reduce the time complexity to O(n). The index of one bucket is calculated by idx=(nums[i]-INT_MIN)/(t+1). The reason I divide t+1 is to avoid the error when t is 0. Then I find out whether that bucket is empty. If not, return true. But if so, I also need to check the bucket idx-1 and bucket idx+1. If the numbers in that two buckets have differences with nums[i] less than or equal to t, return true. Then if all buckets contains more than k numbers, I need to erase the left most number.

This is learned from discuss: https://leetcode.com/discuss/38206/ac-o-n-solution-in-java-using-buckets-with-explanation.

class Solution {
public:
    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
        if(k<1||t<0)
            return false;
        unordered_map<long long,long long> bucket;
        int n=nums.size();
        for(int i=0;i<n;i++)
        {
            long long idx=((long long)nums[i]-INT_MIN)/((long long)t+1);
            if(bucket.find(idx)!=bucket.end()||
                bucket.find(idx-1)!=bucket.end()&&(long long)nums[i]-bucket[idx-1]<=(long long)t||
                    bucket.find(idx+1)!=bucket.end()&&bucket[idx+1]-(long long)nums[i]<=(long long)t)
                        return true;
            bucket.insert(make_pair(idx,nums[i]));
            if(bucket.size()>k)
            {
                idx=((long long)nums[i-k]-INT_MIN)/((long long)t+1);
                bucket.erase(bucket.find(idx));
            }
        }
        return false;
    }
};