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