Contains duplicate 3

Author: Tushar Roy

src/com/interview/misc/ContainsNumberWithinKDistance.java

@@ -0,0 +1,60 @@
+package com.interview.misc;
+
+import java.util.Map;
+import java.util.TreeMap;
+
+/**
+ * Date 10/26/2016
+ * @author Tushar Roy
+ *
+ * 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
+ * Keep a tree map of num and its count. For every new number check if any number exists in map between
+ * num - t and num + t. If yes than return true. If no then add this number to the tree map. Also if tree map
+ * becomes of size k then drop the num[i - k] number from the tree map.
+ *
+ * Time complexity O(nlogk)
+ *
+ * https://leetcode.com/problems/contains-duplicate-iii/
+ */
+public class ContainsNumberWithinKDistance {
+
+    public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
+        if (nums.length == 0 || k == 0) {
+            return false;
+        }
+        TreeMap<Integer, Integer> map = new TreeMap<>();
+        for (int i = 0; i < nums.length; i++) {
+            int lowerEntry = nums[i] - t - 1;
+            int higherEntry = nums[i] + t + 1;
+            Map.Entry<Integer, Integer> higher = map.lowerEntry(higherEntry);
+            if (higher != null && higher.getKey() >= nums[i]) {
+                return true;
+            }
+            Map.Entry<Integer, Integer> lower = map.higherEntry(lowerEntry);
+            if (lower != null && lower.getKey() <= nums[i]) {
+                return true;
+            }
+            if (map.size() == k) {
+                map.compute(nums[i - k], (key, val) -> {
+                    if (val == 1) {
+                        return null;
+                    } else {
+                        return val - 1;
+                    }
+                });
+            }
+            map.compute(nums[i], (key, val) -> {
+                if (val == null) {
+                    return 1;
+                } else {
+                    return val + 1;
+                }
+            });
+        }
+        return false;
+    }
+}