Contains Duplicate III LT220

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.

Example 1:

Input: nums = [1,2,3,1], k = 3, t = 0
Output: true

Example 2:

Input: nums = [1,0,1,1], k = 1, t = 2
Output: true

Example 3:

Input: nums = [1,5,9,1,5,9], k = 2, t = 3
Output: false

Idea 1. Similar to Contains Duplicate II LT219, instead of 0 difference, here is at most t difference, normal hashSet cann't effciently tell if there exists elements (nums[i] - t, nums[i]+t) unless loop the whole range, hence TreeSet could be a good tool, to extract the sorted neighbours of nums[i], and see if the difference to its neighbours is at most t.

Time Complexity: O(NlgK)

Space complexity: O(K)

import java.util.NavigableSet;
class Solution {
    public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
        TreeSet<Integer> window = new TreeSet<>();
        
        for(int right = 0; right < nums.length; ++right) {
            Integer prev = window.floor(nums[right]);
            Integer next = window.higher(nums[right]);
            
            if((prev != null && (long)nums[right] - prev <= t)
               || (next != null && (long)next - nums[right] <= t)) {
                return true;
            }
            window.add(nums[right]);
            
            if(right >= k) {
                window.remove(nums[right-k]);
            }
        }
        
        return false;
    }
}

Idea 2. Interesting idea with buckets to map the range[0...t] to a bucket slot, if nums[i] and nums[j] map to the same bucket, it means that their diff is at most, the difference between the sorted tail of buckets[k] and the sorted head of buckets[k+1] could be in range as well, so need to check two neighbour buckets[k-1] and buckets[k+1].

Note. integer overflow, only convert to long if needed, for example during calcuation (+/-), but no need to change Map<Integer, Integer> to Map<Long, Integer>, also t + 1 could be overflow, do (long)t + 1 instead.

Time complexity: O(N)

Space complexity: O(N)

class Solution {
    public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
        if(t < 0) {
            return false;
        }
        
        Map<Integer, Integer> buckets = new HashMap<>();
        
        for(int right = 0; right < nums.length; ++right) {
            int bucketKey = (int)( ( (long) nums[right] - Integer.MIN_VALUE ) / ( (long)t+1) );
            
            if(buckets.containsKey(bucketKey)
              || (buckets.containsKey(bucketKey-1) && (long)nums[right] - buckets.get(bucketKey-1) <= t)
              || (buckets.containsKey(bucketKey+1) && (long)buckets.get(bucketKey+1) - nums[right] <= t)) {
                return true;
            }
            buckets.put(bucketKey, nums[right]);
            
            if(right >= k) {
                int key = (int)( ( (long)nums[right-k] - Integer.MIN_VALUE ) / ( (long)t+1) );
                buckets.remove(key);
            }
        }
        
        return false;
    }
}