[LeetCode] Contains Duplicate II
Given an array of integers and an integer k, find out whether there there are two distinct indices i and j in the array such that nums[i] = nums[j] and the difference between iand j is at most k.
思路：这里需要注意两个地方，一是at most k 而是时间复杂度是O(n^2)时会TLE
代码：自己首先想到的是双重循环，时间复杂度O(n^2),结果肯定就是TLE
public boolean containsNearbyDuplicate(int[] nums, int k) { int i=0,j=1; while(i<nums.length) { j=1; while(i+j<nums.length && j<=k && nums[i]!=nums[i+j]) { j++; } if(i+j<nums.length && nums[i]==nums[i+j]) return true; i++; } return false; }
明显，题目要求时间复杂度更低的算法，比如O(n)
像这样的在临近找数值的题目，一般采用哈希表或者哈希集合去实现一个窗口。
在本题中采用哈希集合去实现一个长度为K的窗口，end不断向前走，当碰到end-start>k时，就remove掉nums[start]，并且移动start。在K步中碰到相同的数，就返回true
实质就是，将前面的至多K个数存在哈希set里面，然后去找是否存在。时间复杂度O(n)
public boolean containsNearbyDuplicate(int[] nums, int k) { Set<Integer> set=new HashSet<Integer>(); int start=0,end =0; for(int i=0;i<nums.length;i++) { if(!set.contains(nums[i])) { set.add(nums[i]); end++; } else return true; if(end-start>k) { set.remove(nums[start]); start++; } } return false; }
优化：
扩展：
1、Given an array of integers and an integer k, return true if and only if 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.
上面那个题是存在，这个题是存在且只存在一组
这里采用的是哈希图，因为假如使用hashset的话，可能出现这样的情况，{1,2,1,1} 2，由于hashset不存储重复的值，当start=0,end=3时，需要删除1，在进行判断的时候start=1,end=3,而set里面的1已经被删除，会出现错误判断，采用哈希图，保证窗口中有K个值，不管是否重复。定义变量d记录重复出现的次数，这里需要注意的是不管是否存在end始终要往前加。
public boolean containsNearbyDuplicate(int[] nums, int k) { Map<Integer,Integer> map=new HashMap<Integer,Integer>(); int start=0,end =0; int d=0; for(int i=0;i<nums.length;i++) { if(map.containsValue(nums[i])) { d++; } map.put(i,nums[i]); end++; if(end-start>k) { map.remove(start); start++; } } return d==1; }
2、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.
思路：采用两重遍历，TLE
public boolean containsNearbyDuplicate(int[] nums, int k,int t) { if(nums.length==0)return false; Set<Integer> set=new HashSet<Integer>(); int start=0,end =0; //横向窗口 for(int i=0;i<nums.length;i++) { Iterator<Integer> iterator=set.iterator(); while(iterator.hasNext()) { int x=iterator.next(); if(x>=nums[i]-t && x<=nums[i]+t) { return true; } } set.add(nums[i]); end++; if(end-start>k) { set.remove(nums[start]); start++; } } return false; }
采用treeset
import java.util.SortedSet; import java.util.TreeSet; public class Solution { public boolean containsNearbyAlmostDuplicate(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; } }
采用sub的时候，起始点是包含在内的，而终点是不包含在内的，所以这里会产生超过Integer.maxValue的情况（见红色字体），所以需要使用Long