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;
}
}