220. Contains Duplicate III

Given an array of integers, find out whether there are two distinct indices i and j in the array such that the absolute difference between nums[i] and nums[j] is at most t and the absolute difference between i and j is at most k.

First Solution:

We could use a TreeSet to maintain the previous K elements in the array and query the floor and ceiling in lgk time,

Total runtime is O(nlgk).

Code:

public class Solution {
    public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
         TreeSet<Long> ts = new TreeSet<>();
         int i = 0;
         
         while(i < nums.length){
             
             Long ceiling = ts.ceiling((long)nums[i]);
             Long floor = ts.floor((long)nums[i]);
             if((ceiling != null && ceiling - nums[i] <= t)
                    || (floor != null && nums[i] - floor <= t)){
                        return true;
             }
             ts.add((long)nums[i]);
             if(ts.size() == k + 1){
                 ts.remove((long)nums[i - k]);
             }
             i++;
         }
         
         return false;
    }
}

Second solution.

We could use a bucket to represent a range of numbers. The size of the bucket should be t ( [0-t] [t + 1 - 2t + 1] ). If there are 2 numbers in the same bucket return true,

If the difference of numbers in adjacent buckets are less than t, return true.

Runtime O(n).

public class Solution {
    public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
         HashMap<Long,Long> hm = new HashMap();
         if(k < 0 || t < 0) return false;
         
         long len = t + 1l;
         for(int i = 0 ; i < nums.length; i++){
             long newNum =  1l * nums[i] - Integer.MIN_VALUE;
             long bucketNum = newNum / len;
             if(hm.containsKey(bucketNum)) return true;
             if(hm.containsKey(bucketNum - 1) && newNum - hm.get(bucketNum - 1) <= t) return true;
             if(hm.containsKey(bucketNum + 1) && hm.get(bucketNum + 1) - newNum <= t) return true;
             hm.put(bucketNum,newNum);
             if(hm.size() == k + 1){
                 long toRemoveNum = (1l * nums[i - k] - Integer.MIN_VALUE);
                 long toRemove = toRemoveNum / len;
                 hm.remove(toRemove);
             }
         }
         
         return false;
    }
}