[array]219. Contains Duplicate II

219. Contains Duplicate II

Given an integer array nums and an integer k, return true if there are two distinct indices i and j in the array such that nums[i] == nums[j] and abs(i - j) <= k.

Example 1:

Input: nums = [1,2,3,1], k = 3
Output: true

Example 2:

Input: nums = [1,0,1,1], k = 1
Output: true

Example 3:

Input: nums = [1,2,3,1,2,3], k = 2
Output: false

Constraints:

1 <= nums.length <= 105
-109 <= nums[i] <= 109
0 <= k <= 105

solution1 哈希表

从左到右遍历数组 \textit{nums}nums，当遍历到下标 ii 时，如果存在下标 j < ij<i 使得 \textit{nums}[i] = \textit{nums}[j]nums[i]=nums[j]，则当 i - j \le ki−j≤k 时即找到了两个符合要求的下标 jj 和 ii。

如果在下标 ii 之前存在多个元素都和 \textit{nums}[i]nums[i] 相等，为了判断是否存在满足 \textit{nums}[i] = \textit{nums}[j]nums[i]=nums[j] 且 i - j \le ki−j≤k 的下标 jj，应该在这些元素中寻找下标最大的元素，将最大下标记为 jj，判断 i - j \le ki−j≤k 是否成立。

如果 i - j \le ki−j≤k，则找到了两个符合要求的下标 jj 和 ii；如果 i - j > ki−j>k，则在下标 ii 之前不存在任何元素满足与 \textit{nums}[i]nums[i] 相等且下标差的绝对值不超过 kk，理由如下。

假设存在下标 j’j
′
满足 j’ < j < ij
′
<j<i 且 \textit{nums}[j’] = \textit{nums}[j] = \textit{nums}[i]nums[j
′
]=nums[j]=nums[i]，则 i - j’ > i - ji−j
′

i−j，由于 i - j > ki−j>k，因此必有 i - j’ > ki−j
′
k。

因此，当遍历到下标 ii 时，如果在下标 ii 之前存在与 \textit{nums}[i]nums[i] 相等的元素，应该在这些元素中寻找最大的下标 jj，判断 i - j \le ki−j≤k 是否成立。

可以使用哈希表记录每个元素的最大下标。从左到右遍历数组 \textit{nums}nums，当遍历到下标 ii 时，进行如下操作：

如果哈希表中已经存在和 \textit{nums}[i]nums[i] 相等的元素且该元素在哈希表中记录的下标 jj 满足 i - j \le ki−j≤k，返回 \text{true}true；

将 \textit{nums}[i]nums[i] 和下标 ii 存入哈希表，此时 ii 是 \textit{nums}[i]nums[i] 的最大下标。

上述两步操作的顺序不能改变，因为当遍历到下标 ii 时，只能在下标 ii 之前的元素中寻找与当前元素相等的元素及该元素的最大下标。

当遍历结束时，如果没有遇到两个相等元素的下标差的绝对值不超过 kk，返回 \text{false}false。

JavaC#C++CPython3GolangJavaScript

class Solution {
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k) {
        unordered_map<int, int> dictionary;
        int length = nums.size();
        for (int i = 0; i < length; i++) {
            int num = nums[i];
            if (dictionary.count(num) && i - dictionary[num] <= k) {
                return true;
            }
            dictionary[num] = i;
        }
        return false;
    }
};

复杂度分析

时间复杂度：O(n)O(n)，其中 nn 是数组 \textit{nums}nums 的长度。需要遍历数组一次，对于每个元素，哈希表的操作时间都是 O(1)O(1)。

空间复杂度：O(n)O(n)，其中 nn 是数组 \textit{nums}nums 的长度。需要使用哈希表记录每个元素的最大下标，哈希表中的元素个数不会超过 nn。

solution2 滑动窗口

考虑数组 \textit{nums}nums 中的每个长度不超过 k + 1k+1 的滑动窗口，同一个滑动窗口中的任意两个下标差的绝对值不超过 kk。如果存在一个滑动窗口，其中有重复元素，则存在两个不同的下标 ii 和 jj 满足 \textit{nums}[i] = \textit{nums}[j]nums[i]=nums[j] 且 |i - j| \le k∣i−j∣≤k。如果所有滑动窗口中都没有重复元素，则不存在符合要求的下标。因此，只要遍历每个滑动窗口，判断滑动窗口中是否有重复元素即可。

如果一个滑动窗口的结束下标是 ii，则该滑动窗口的开始下标是 \max(0, i - k)max(0,i−k)。可以使用哈希集合存储滑动窗口中的元素。从左到右遍历数组 \textit{nums}nums，当遍历到下标 ii 时，具体操作如下：

如果 i > ki>k，则下标 i - k - 1i−k−1 处的元素被移出滑动窗口，因此将 \textit{nums}[i - k - 1]nums[i−k−1] 从哈希集合中删除；

判断 \textit{nums}[i]nums[i] 是否在哈希集合中，如果在哈希集合中则在同一个滑动窗口中有重复元素，返回 \text{true}true，如果不在哈希集合中则将其加入哈希集合。

当遍历结束时，如果所有滑动窗口中都没有重复元素，返回 \text{false}false。

JavaC#C++CPython3GolangJavaScript

class Solution {
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k) {
        unordered_set<int> s;
        int length = nums.size();
        for (int i = 0; i < length; i++) {
            if (i > k) {
                s.erase(nums[i - k - 1]);
            }
            if (s.count(nums[i])) {
                return true;
            }
            s.emplace(nums[i]);
        }
        return false;
    }
};

复杂度分析

时间复杂度：O(n)O(n)，其中 nn 是数组 \textit{nums}nums 的长度。需要遍历数组一次，对于每个元素，哈希集合的操作时间都是 O(1)O(1)。

空间复杂度：O(k)O(k)，其中 kk 是判断重复元素时允许的下标差的绝对值的最大值。需要使用哈希集合存储滑动窗口中的元素，任意时刻滑动窗口中的元素个数最多为 k + 1k+1 个。

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/contains-duplicate-ii/solution/cun-zai-zhong-fu-yuan-su-ii-by-leetcode-kluvk/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

解题思路
1.滑动窗口
2.哈希map
3.暴力解法

代码

滑动窗口

class Solution {
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k) {
        unordered_set<int> set;
        for(int i = 0; i < nums.size(); i ++) {
            if(set.count(nums[i])) return true;
            set.insert(nums[i]);
            if(set.size() > k) set.erase(nums[i - k]);
        }
        return false;
    }
};

map

class Solution {
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k) {
        unordered_map<int, int>map;
        for(int i = 0; i < nums.size(); i ++) {
            if(map.count(nums[i]) && abs(map[nums[i]] - i) <= k) {
                return true;
            }
            map[nums[i]] = i;
        }
        return false;
    }
};

暴力

class Solution {
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k) {
        for(int i = 0; i < nums.size(); i ++) {
            for(int j = i + 1; j < nums.size(); j ++) {
                if(nums[i] == nums[j] && abs(i - j) <= k) 
                    return true;
            }
        }
        return false;
    }
};

作者：OrangeMan
链接：https://leetcode.cn/problems/contains-duplicate-ii/solution/cjian-ji-dai-ma-hua-dong-chuang-kou-ha-x-q2wn/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。