Modify solution 220

leetcode/0220.Contains-Duplicate-III/220. Contains Duplicate III.go

@@ -1,51 +1,38 @@
 package leetcode
 
-import "sort"
-
-// 解法一 排序 + 滑动窗口
+// 解法一 桶排序
 func containsNearbyAlmostDuplicate(nums []int, k int, t int) bool {
-	if len(nums) < 2 {
+	if k <= 0 || t < 0 || len(nums) < 2 {
 		return false
 	}
-	elemList := make([]*elem, len(nums))
-	for i, num := range nums {
-		elemList[i] = &elem{num, i}
-	}
-	sort.SliceStable(elemList, func(i, j int) bool {
-		if elemList[i].val != elemList[j].val {
-			return elemList[i].val < elemList[j].val
+	buckets := map[int]int{}
+	for i := 0; i < len(nums); i++ {
+		// Get the ID of the bucket from element value nums[i] and bucket width t + 1
+		key := nums[i] / (t + 1)
+		// -7/9 = 0, but need -7/9 = -1
+		if nums[i] < 0 {
+			key--
 		}
-		return elemList[i].idx < elemList[j].idx
-	})
-	i, j := 0, 1
-	for j < len(elemList) {
-		if elemList[j].val-elemList[i].val <= t {
-			if abs(elemList[j].idx-elemList[i].idx) <= k {
-				return true
-			}
-			j++
-		} else {
-			i++
-			if j <= i {
-				j++
-			}
+		if _, ok := buckets[key]; ok {
+			return true
 		}
+		// check the lower bucket, and have to check the value too
+		if v, ok := buckets[key-1]; ok && nums[i]-v <= t {
+			return true
+		}
+		// check the upper bucket, and have to check the value too
+		if v, ok := buckets[key+1]; ok && v-nums[i] <= t {
+			return true
+		}
+		// maintain k size of window
+		if len(buckets) >= k {
+			delete(buckets, nums[i-k]/(t+1))
+		}
+		buckets[key] = nums[i]
 	}
 	return false
 }
 
-func abs(a int) int {
-	if a > 0 {
-		return a
-	}
-	return -a
-}
-
-type elem struct {
-	val int
-	idx int
-}
-
 // 解法二 滑动窗口 + 剪枝
 func containsNearbyAlmostDuplicate1(nums []int, k int, t int) bool {
 	if len(nums) <= 1 {
@@ -66,3 +53,10 @@ func containsNearbyAlmostDuplicate1(nums []int, k int, t int) bool {
 	}
 	return false
 }
+
+func abs(a int) int {
+	if a > 0 {
+		return a
+	}
+	return -a
+}

leetcode/0220.Contains-Duplicate-III/README.md

@@ -32,3 +32,4 @@ Given an array of integers, find out whether there are two distinct indices i
 - 给出一个数组，要求在数组里面找到 2 个索引，`i` 和 `j`，使得 `| nums[i] - nums[j] | ≤ t` ，并且 `| i - j | ≤  k` 。
 - 这是一道滑动窗口的题目。第一想法就是用 `i` 和 `j` 两个指针，针对每个 `i` ，都从 `i + 1` 往后扫完整个数组，判断每个 `i` 和 `j` ，判断是否满足题意。`j` 在循环的过程中注意判断剪枝条件 `| i - j | ≤  k`。这个做法的时间复杂度是 O(n^2)。这个做法慢的原因在于滑动窗口的左边界和右边界在滑动过程中不是联动滑动的。
 - 于是考虑，如果数组是有序的呢？把数组按照元素值从小到大进行排序，如果元素值相等，就按照 index 从小到大进行排序。在这样有序的数组中找满足题意的 `i` 和 `j`，滑动窗口左边界和右边界就是联动的了。窗口的右边界滑到与左边界元素值的差值 ≤ t 的地方，满足了这个条件再判断 `| i - j | ≤  k`，如果右边界与左边界元素值的差值 > t 了，说明该把左边界往右移动了(能这样移动的原因就是因为我们将数组元素大小排序了，右移是增大元素的方向)。移动左边界的时候需要注意左边界不能超过右边界。这样滑动窗口一次滑过整个排序后的数组，就可以判断是否存在满足题意的 `i` 和 `j` 。这个做法的时间主要花在排序上了，时间复杂度是 O(n log n)。
+- 本题最优解是利用桶排序的思想。`| i - j | ≤  k` 这个条件利用一个窗口大小为 k 来维护。重点在 `| nums[i] - nums[j] | ≤ t` 这个条件如何满足。利用桶排序的思想，将 `nums[i]` 所有元素分为 ...,`[0,t]`,`[t+1,2t+1]`,...。每个区间的大小为 `t + 1`。每个元素现在都对应一个桶编号。进行 3 次查找即可确定能否找到满足这个 `| nums[i] - nums[j] | ≤ t` 条件的数对。如果在相同的桶中找到了元素，那么说明能找到这样的 i 和 j。还有 2 种可能对应桶边界的情况。如果存在前一个桶中的元素能使得相差的值也 `≤ t`，这样的数对同样满足题意。最后一种情况是，如果存在后一个桶中的元素能使得相差的值也 `≤ t`，这样的数对同样满足题意。查询 3 次，如果都不存在，说明当前的 i 找不到满足题意的 j。继续循环寻找。循环一遍都找不到满足题意的数对，输出 false。

website/content/ChapterFour/0220.Contains-Duplicate-III.md

@@ -32,6 +32,7 @@ Given an array of integers, find out whether there are two distinct indices i
 - 给出一个数组，要求在数组里面找到 2 个索引，`i` 和 `j`，使得 `| nums[i] - nums[j] | ≤ t` ，并且 `| i - j | ≤  k` 。
 - 这是一道滑动窗口的题目。第一想法就是用 `i` 和 `j` 两个指针，针对每个 `i` ，都从 `i + 1` 往后扫完整个数组，判断每个 `i` 和 `j` ，判断是否满足题意。`j` 在循环的过程中注意判断剪枝条件 `| i - j | ≤  k`。这个做法的时间复杂度是 O(n^2)。这个做法慢的原因在于滑动窗口的左边界和右边界在滑动过程中不是联动滑动的。
 - 于是考虑，如果数组是有序的呢？把数组按照元素值从小到大进行排序，如果元素值相等，就按照 index 从小到大进行排序。在这样有序的数组中找满足题意的 `i` 和 `j`，滑动窗口左边界和右边界就是联动的了。窗口的右边界滑到与左边界元素值的差值 ≤ t 的地方，满足了这个条件再判断 `| i - j | ≤  k`，如果右边界与左边界元素值的差值 > t 了，说明该把左边界往右移动了(能这样移动的原因就是因为我们将数组元素大小排序了，右移是增大元素的方向)。移动左边界的时候需要注意左边界不能超过右边界。这样滑动窗口一次滑过整个排序后的数组，就可以判断是否存在满足题意的 `i` 和 `j` 。这个做法的时间主要花在排序上了，时间复杂度是 O(n log n)。
+- 本题最优解是利用桶排序的思想。`| i - j | ≤  k` 这个条件利用一个窗口大小为 k 来维护。重点在 `| nums[i] - nums[j] | ≤ t` 这个条件如何满足。利用桶排序的思想，将 `nums[i]` 所有元素分为 ...,`[0,t]`,`[t+1,2t+1]`,...。每个区间的大小为 `t + 1`。每个元素现在都对应一个桶编号。进行 3 次查找即可确定能否找到满足这个 `| nums[i] - nums[j] | ≤ t` 条件的数对。如果在相同的桶中找到了元素，那么说明能找到这样的 i 和 j。还有 2 种可能对应桶边界的情况。如果存在前一个桶中的元素能使得相差的值也 `≤ t`，这样的数对同样满足题意。最后一种情况是，如果存在后一个桶中的元素能使得相差的值也 `≤ t`，这样的数对同样满足题意。查询 3 次，如果都不存在，说明当前的 i 找不到满足题意的 j。继续循环寻找。循环一遍都找不到满足题意的数对，输出 false。
 
 
 ## 代码
@@ -40,43 +41,44 @@ Given an array of integers, find out whether there are two distinct indices i
 
 package leetcode
 
-import "sort"
-
-// 解法一 排序 + 滑动窗口
+// 解法一 桶排序
 func containsNearbyAlmostDuplicate(nums []int, k int, t int) bool {
-	if len(nums) < 2 {
+	if k <= 0 || t < 0 || len(nums) < 2 {
 		return false
 	}
-	elemList := make([]*elem, len(nums))
-	for i, num := range nums {
-		elemList[i] = &elem{num, i}
-	}
-	sort.SliceStable(elemList, func(i, j int) bool {
-		if elemList[i].val != elemList[j].val {
-			return elemList[i].val < elemList[j].val
+	buckets := map[int]int{}
+	for i := 0; i < len(nums); i++ {
+		// Get the ID of the bucket from element value nums[i] and bucket width t + 1
+		key := nums[i] / (t + 1)
+		// -7/9 = 0, but need -7/9 = -1
+		if nums[i] < 0 {
+			key--
 		}
-		return elemList[i].idx < elemList[j].idx
-	})
-	i, j := 0, 1
-	for j < len(elemList) {
-		if elemList[j].val-elemList[i].val <= t {
-			if abs(elemList[j].idx-elemList[i].idx) <= k {
-				return true
-			}
-			j++
-		} else {
-			i++
-			if j <= i {
-				j++
-			}
+		if _, ok := buckets[key]; ok {
+			return true
 		}
+		// check the lower bucket, and have to check the value too
+		if v, ok := buckets[key-1]; ok && nums[i]-v <= t {
+			return true
+		}
+		// check the upper bucket, and have to check the value too
+		if v, ok := buckets[key+1]; ok && v-nums[i] <= t {
+			return true
+		}
+		// maintain k size of window
+		if len(buckets) >= k {
+			delete(buckets, nums[i-k]/(t+1))
+		}
+		buckets[key] = nums[i]
 	}
 	return false
 }
 
-type elem struct {
-	val int
-	idx int
+func abs(a int) int {
+	if a > 0 {
+		return a
+	}
+	return -a
 }
 
 // 解法二 滑动窗口 + 剪枝