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 difference between nums[i] and nums[j] is at most t and the difference between i and j is at most k.

Solution 1

// O(tn)
	public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
		if (nums.length < 2 || k < 1 || t < 0)
			return false;
		ValuePosPair[] valPosArr = new ValuePosPair[nums.length];
		for (int i = 0; i < nums.length; i++)
			valPosArr[i] = new ValuePosPair(nums[i], i);
		Arrays.sort(valPosArr);
		for (int i = 0; i < valPosArr.length; i++) {
			for (int j = i + 1; j < valPosArr.length
					&& ((long) valPosArr[j].val - (long) valPosArr[i].val <= (long) t); j++) {
				if (Math.abs(valPosArr[j].pos - valPosArr[i].pos) <= k)
					return true;
			}
		}
		return false;
	}

	class ValuePosPair implements Comparable<ValuePosPair> {

		int val;
		int pos;

		ValuePosPair(int v, int p) {
			val = v;
			pos = p;
		}

		public int compareTo(ValuePosPair x) {
			return this.val - x.val;
		}
	}

Solution 2

//O(N log K)
	public static boolean containsNearbyAlmostDuplicate2(int[] nums, int k, int t) {
		 if (nums.length < 2 || k == 0) {
		        return false;
		    }
		    TreeSet<Long> set = new TreeSet<>();
		    int i = 0;
		    while(i < nums.length){
		        Long floor = set.floor((long) nums[i]);
		        Long ceiling = set.ceiling((long) nums[i]);
		        if ((floor != null && nums[i] - floor <= t ) ||
		                (ceiling != null && ceiling - nums[i] <= t)) {
		            return true;
		        }
		        set.add((long) nums[i++]);
		        if (i > k) {
		            set.remove((long) nums[i - k - 1]);
		        }
		    }
		    return false;
	}

Solution 3

public static boolean containsNearbyAlmostDuplicate3(int[] nums, int k, int t) {

		if (k < 1 || t < 0 || nums == null || nums.length < 2) {
			return false;
		}
		SortedSet<Long> set = new TreeSet<Long>();
		for (int j = 0; j < nums.length; j++) {
			SortedSet<Long> subSet = set.subSet((long) nums[j] - t, (long) nums[j] + t + 1);
			// 集合不为空，则表示找到解
			if (!subSet.isEmpty()) {
				return true;
			}
			if (j >= k) {
				set.remove((long) nums[j - k]);
			}
			set.add((long) nums[j]);
		}
		return false;
	}

Solution 4

//O(N) bucket
	public boolean containsNearbyAlmostDuplicate4(int[] nums, int k, int t) {
        if (k < 1 || t < 0) return false;
        Map<Long, Long> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            long remappedNum = (long) nums[i] - Integer.MIN_VALUE;
            long bucket = remappedNum / ((long) t + 1);
            if (map.containsKey(bucket)
                    || (map.containsKey(bucket - 1) && remappedNum - map.get(bucket - 1) <= t)
                        || (map.containsKey(bucket + 1) && map.get(bucket + 1) - remappedNum <= t))
                            return true;
            if (map.entrySet().size() >= k) {
                long lastBucket = ((long) nums[i - k] - Integer.MIN_VALUE) / ((long) t + 1);
                map.remove(lastBucket);
            }
            map.put(bucket, remappedNum);
        }
        return false;
    }