217. Contains Duplicate && 219. Contains Duplicate II && 220. Contains Duplicate III

217. Contains Duplicate

Given an array of integers, find if the array contains any duplicates. Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.

Hide Tags

 Array Hash Table

Hide Similar Problems

 (E) Contains Duplicate II (M) Contains Duplicate III

 

public class Solution {
    public boolean containsDuplicate(int[] nums) {
        HashSet<Integer> all = new HashSet<Integer>();
        for(Integer n : nums)
        {
            if(!all.add(n))
                return true;
        }
        return false;
    }
}

 

219. Contains Duplicate II

Given an array of integers and an integer k, find out whether there are two distinct indices i and j in the array such that nums[i] = nums[j] and the difference between i and j is at most k.

Hide Tags

 Array Hash Table

Hide Similar Problems

 (E) Contains Duplicate (M) Contains Duplicate III

 

Solution 1: Even though Time Limit Exceeded. The idea is good. One small hash set is enough.

public class Solution {
    public boolean containsNearbyDuplicate(int[] nums, int k) {
        Set<Integer> set = new HashSet<Integer>(k); //have k items in set at most.
        for(int i = 0; i < nums.length; i++){
            if(i > k) 
                set.remove(nums[i-k-1]); //pop out the last item that is out of the range.
            if(!set.add(nums[i])) 
                return true;
        }
        return false;
    }
}

 

Solution 2: Use HashMap

public class Solution {
    public boolean containsNearbyDuplicate(int[] nums, int k) {
        HashMap<Integer, Integer> n2ind = new HashMap<>();
        for(int i = 0; i<nums.length; ++i)
        {
            int n = nums[i];
            Integer pos = n2ind.get(n);
            if(pos != null && i - pos <= k)
                return true;
            n2ind.put(n, i);
        }
        return false;
    }
}

 

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

Hide Tags

 Binary Search Tree

Hide Similar Problems

 (E) Contains Duplicate (E) Contains Duplicate II

 

 

O(N) solution:

?????

?????

 

O(Nlgk) solution:

public class Solution {
    //find i and j, such that
    //1. |i-j| <= k
    //2. |f(i)-f(j)| <= t
    public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
        if (nums == null || nums.length == 0 || k <= 0)
            return false;

        TreeSet<Integer> window = new TreeSet<>();
        for (int i = 0; i < nums.length; ++i) {
            int curr = nums[i];
            if(!window.isEmpty())
            {
                //check if any number in the window falls in the range
                //[curr-t, curr+t], curr+t has an issue for Int.max + Int.max. Or change type to Long.
                Integer ceiling = window.ceiling(curr-t);
                Integer floor = window.floor(curr+t);
                if(floor != null && curr <= floor
                  ||
                  ceiling != null && curr >= ceiling)
                    return true;
            }
            if (i>=k)
                window.remove(nums[i - k]);
            window.add(curr);
        }

        return false;
    }
}