【leetcode】存在重复元素II

Solution 1: 滑动窗口

超出时间限制的方案

这种解法的思路也是维护一个大小是(k+1)窗口，但是在具体实现方面如果采用python的list，那么Note(*)部分查找list中是否存在当前元素超过时间限制

class Solution(object):
    def containsNearbyDuplicate(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: bool
        """
        
        hash_list = []
        for num in nums:
            if len(hash_list) == (k+1):
                hash_list.pop(0) # 删除头元素，标志是0
            if num in hash_list:
                # 删除头元素之后仍然存在num元素，返回True
                return True
            else:
                # 否则添加num元素
                hash_list.append(num)
        return False

参考题解

这种解法是Solution 3的优化，将Solution 3的哈希表空间复杂度降低到O(k)，需要注意的是在具体实现方面，如果采用python的集合set，也不需要记录滑动窗口开始的下标，因为当前元素下标-k-1是滑动窗口开始元素的下标

参考题解：https://leetcode.cn/problems/contains-duplicate-ii/solutions/13564/hua-jie-suan-fa-219-cun-zai-zhong-fu-yuan-su-ii-by/

参考题解的思路很妙啊，非常巧妙的利用的hashset的不重复性以及限制元素个数确定存在的重复元素。

class Solution:
    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
		s = set()
        for i, num in enumerate(nums):
            if i > k:
                s.remove(nums[i - k - 1])
            if num in s:
                return True
            s.add(num)
        return False

根据官方题解的思路复现代码

容易出现bug的地方：

Note(1) 如果当前指针>=k，注意这里k是从1计数的，当前指针i是从0开始计数的，所以滑动窗口的第一个元素是nums[i-k]

Note(2) 这里没有判断集合的长度，也就是滑动窗口的长度，因为数组遍历从前往后遍历，i不足k的时候，不断往滑动窗口也就是集合增加元素，i>=k的时候（不是i==k），滑动窗口已经填满了

class Solution:
    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
		s = set() # 用集合存放滑动窗口的元素，注意集合的元素是有序排列的，pop操作弹出最后一个元素，不一定是滑动窗口的开始元素
        for i, item in enumerate(nums):
        	# 如果当前元素在集合中，那么返回True
            if item in s:
                return True
            # 如果当前元素不在集合中，那么执行下面的操作
            # 将当前元素添加到集合中
            s.add(item)
            # Note(1) 如果当前指针>=k，注意这里k是从1计数的，当前指针i是从0开始计数的，所以滑动窗口的第一个元素是nums[i-k]
            # Note(2) 这里没有判断集合的长度，也就是滑动窗口的长度，因为数组遍历从前往后遍历，i不足k的时候，不断往滑动窗口也就是集合增加元素，i>=k的时候（不是i==k），滑动窗口已经填满了
            if i >= k:
                s.remove(nums[i - k])
        return False

Solution 2：两个哈希表分别记录次数和出现的位置

class Solution(object):
    def containsNearbyDuplicate(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: bool
        """
        
        hash_map_time = {} # 记录次数
        hash_map_loc = {} # 记录出现的位置
        for i in range(0, len(nums)):
            if not hash_map_time.has_key(nums[i]):
                # 第一次出现，记录出现的次数是1，并且记录出现的位置
                hash_map_time[nums[i]] = (1, i)
            else:
                # 不是第一次出现，记录的次数加1
                # 如果下一次出现的位置和已经保存的位置绝对值之差小于等于k，返回True
                if abs(i - hash_map_time[nums[i]][1]) <= k:
                    return True
                # 如果下一次出现的位置和已经保存的位置绝对值之差大于k -> 记录次数+1，更新为下一次出现的位置
                else:
                    hash_map_time[nums[i]] = (hash_map_time[nums[i]][0]+1, i)
        return False

Solution 3: 优化哈希表逻辑

时间复杂度：O(N)
空间复杂度：哈希表的空间复杂度O(N)

class Solution:
    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
        # 使用一个哈希表，记录元素上一次出现的下标
        hash_map = {}
        for i in range(0, len(nums)):
            # 当前元素在哈希表中，并且(当前下标 - 哈希表记录的元素上一次出现的下标) <=k，那么返回True
            if nums[i] in hash_map and (i - hash_map[nums[i]]) <= k:
                return True
            # 接下来，更新哈希表，它包含两个情况
            #（1）当前元素不在哈希表中，那么记录当前元素下标
            # (2) 当前元素在哈希表中，但是(当前下标 - 哈希表记录的元素上一次出现的下标) <=k，那么记录新的下标，即使后面再出现这个元素，计算下标也只和上一次相同元素下标有关，不会再和上上一次相同元素下标有关
            hash_map[nums[i]] = i
        return False