fix: 加入暴力解

Author: lucifer

problems/220.contains-duplicate-iii.md

@@ -35,7 +35,55 @@ https://leetcode-cn.com/problems/contains-duplicate-iii/
 
 - 暂无
 
-## 思路
+## 暴力（超时）
+
+### 思路
+
+最简单的思路就是双层循环，找出所有的两两组合。然后逐个判断其是否满足 `nums [i] 和 nums [j] 的差的绝对值最大为 t，并且 i 和 j 之间的差的绝对值最大为 ķ。`
+
+### 代码
+
+```python
+class Solution:
+    def containsNearbyAlmostDuplicate(self, nums: List[int], k: int, t: int) -> bool:
+        for i in range(len(nums)):
+            for j in range(i + 1, len(nums)):
+                if abs(nums[i] - nums[j]) <= t and j - i  <= k:
+                    return True
+        return False
+```
+
+**复杂度分析**
+
+- 时间复杂度：$O(N ^ 2)$
+- 空间复杂度：$O(1)$
+
+## 暴力 + 剪枝 （超时）
+
+### 思路
+
+上述的内存循环可以稍微优化一下， 之前我们从 i + 1 到 len(nums)，实际上我们只需要 i + 1 到 min(len(nums), i + k + 1)。这样我们的 `j - i <= k` 也可以省略了。
+
+### 代码
+
+```python
+class Solution:
+    def containsNearbyAlmostDuplicate(self, nums: List[int], k: int, t: int) -> bool:
+        for i in range(len(nums)):
+            for j in range(i + 1, min(len(nums), i + k + 1)):
+                if abs(nums[i] - nums[j]) <= t:
+                    return True
+        return False
+```
+
+**复杂度分析**
+
+- 时间复杂度：$O(N ^ 2)$
+- 空间复杂度：$O(1)$
+
+## 分桶 （通过）
+
+### 思路
 
 这道题是 [219. 存在重复元素 II](https://github.com/azl397985856/leetcode/blob/master/problems/219.contains-duplicate-ii.md) 的进阶版。那道题的条件是 `nums[i] == nums[j]`, 而这道题则更加宽泛，是`nums [i] 和 nums [j] 的差的绝对值小于等于 t `。
 
@@ -53,23 +101,36 @@ https://leetcode-cn.com/problems/contains-duplicate-iii/
 
 另外由于题目限定是索引差小于等于 k，因此我们可以固定一个窗口大小为 k 的滑动窗口，每次都仅处理窗口内的元素，这样可以保证桶内的数任意两个数都满足**索引之差的绝对值小于等于 k**。 因此我们需要清除哈希表中过期（不在窗口内）的信息。
 
-## 关键点
+具体算法：
+
+- 我们将数据分到 M 个桶 中。
+- 每个数字 nums[i] 都被我们分配到一个桶中
+- 分配的依据就是 nums[i] // (t + 1)
+- 这样相邻桶内的数字最多相差`2 * t + 1`
+- 不相邻的桶一定不满足相差小于等于 t
+- 同一个桶内的数字最多相差`t`
+
+1. 因此如果命中同一个桶内，那么直接返回 True
+2. 如果命中相邻桶，我们再判断一下是否满足 相差 <= t
+3. 否则返回 False
+
+需要注意的是，由于题目有索引相差 k 的要求，因此要维护一个大小为 k 的窗口，定期清除桶中`过期`的数字。
+
+### 关键点
 
 - 分桶排序思想的应用
 
-## 代码
+### 代码
 
-- 语言支持：Python3
+我们使用哈希表来模拟桶，key 就是桶号，value 就是数字本身。
 
-Python3 Code:
+Python 3:
 
 ```python
-
 class Solution:
     def containsNearbyAlmostDuplicate(self, nums: List[int], k: int, t: int) -> bool:
         bucket = dict()
-        if t < 0:
-            return False
+        if t < 0: return False
         for i in range(len(nums)):
             nth = nums[i] // (t + 1)
             if nth in bucket:
@@ -79,11 +140,41 @@ class Solution:
             if nth + 1 in bucket and abs(nums[i] - bucket[nth + 1]) <= t:
                 return True
             bucket[nth] = nums[i]
-            # 如果数组有相同的数会有影响么？答案是不会，因为如果有相同的数，我们直接就会在前面返回 true 了。
-            if i >= k:
-                bucket.pop(nums[i - k] // (t + 1))
+            if i >= k: bucket.pop(nums[i - k] // (t + 1))
         return False
+```
 
+C++
+
+```c++
+class Solution {
+public:
+    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
+        if(t<0) return false;
+        //t+1可能会溢出，所以要+ 1LL
+        long long mod = t + 1LL;
+        unordered_map<long long,long long> buck;
+        for(int i=0;i<nums.size();i++)
+        {
+            long long nth = nums[i] / mod;
+            //可能nums[i]为负数，比如-4 / 5 以及 -4 / 5都等于0，所以负数要向下移动一位
+            if(nums[i] < 0) nth--;
+            //这里要用find 不能直接[],因为可能本身存储的数字就为0
+            if(buck.find(nth)!=buck.end())
+                return true;
+            else if(buck.find(nth-1)!=buck.end() && abs(nums[i] - buck[nth-1]) <= t)
+                return true;
+            else if(buck.find(nth+1)!=buck.end() && abs(nums[i] - buck[nth+1]) <= t)
+                return true;
+            buck[nth] = nums[i];
+            if(i >= k)
+            {
+                buck.erase(nums[i - k] / mod);
+            }
+        }
+        return false;
+    }
+};
 ```
 
 **复杂度分析**