【leetcode题解】【再看一遍】【86】【M】Contains Duplicate III

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.

Subscribe to see which companies asked this question

The idea is like the bucket sort algorithm. Suppose we have consecutive buckets covering the range of nums with each bucket a width of (t+1). If there are two item with difference <= t, one of the two will happen:

(1) the two in the same bucket
(2) the two in neighbor buckets

Note that we do not need to actually allocate a lot of buckets. At any time there will only be at most min(k, n) buckets. All we need to do is calculate the label of the bucket m = value/(t+1), and check the buckets m
- 1, m, m + 1. The whole algorithm is then O(n).

借鉴桶排序的的思想+滑动窗口

如果： | nums[i] - nums[j] | <= t 式a

等价： | nums[i] / t - nums[j] / t | <= 1 式b

推出： | floor(nums[i] / t) - floor(nums[j] / t) | <= 1 式c

​等价： floor(nums[j] / t) ∈ {floor(nums[i] / t) - 1, floor(nums[i] / t), floor(nums[i] / t) + 1} 式d

运行结果长这个样子

Your input

[1,3,111,11114,111115,1111111,11111112,11111113]
3
1

Your stdout

{}

{0: 1}

{0: 1, 1: 3}

{0: 1, 1: 3, 55: 111}

{0: 1, 1: 3, 5557: 11114, 55: 111}

{1: 3, 55557: 111115, 5557: 11114, 55: 111}

{555555: 1111111, 55557: 111115, 5557: 11114, 55: 111}
{555555: 1111111, 5555556: 11111112, 55557: 111115, 5557: 11114}

注释了的是原来的算法，想法不对，又太笨。

class Solution(object):
def containsNearbyAlmostDuplicate(self, nums, k, t):

if t < 0:
return False

l = len(nums)
d = {}
t += 1

# 1/3 = 0
#-1/3 = -1

for i in xrange(l):
print d
if i > k:
del d[nums[i - k - 1] / t]# 维护一个大小为k+1的桶
m = nums[i] / t
if m in d:
return True
elif m-1 in d and abs(nums[i] - d[m-1]) < t:
return True
elif m+1 in d and abs(nums[i] - d[m+1]) < t:
return True

d[m] = nums[i]
return False

'''
l = len(nums)
if not nums:
return 0 < k
if l == 1 or k == 0 or t < 0:
return False
if l <= k:
for i in range(0,l-1):
if abs(nums[i+1] - nums[i]) <= t:
return True
return False

i = k - 1
df = [0]*(k )

temp = nums[:k]
temp.sort()
for ii in range(0,k):
print ii
if ii == l-1:
break
df[ii] = (temp[ii+1]-temp[ii])
#df.sort()
print df
minn = min(df)
if minn <= t:
return True

print df
while i < l-1:
i += 1
temp_df = abs(nums[i]-nums[i-1])
if temp_df < minn:
df.remove(minn)
minn = temp_df
df.append(minn)
#print df
if minn <= t:
return True

return False
'''