Leetcode 查找（查找表、对撞指针）
查找表
数据结构
第一类： 查找有无–set
元素’a’是否存在，通常用set：集合
set只存储键，而不需要对应其相应的值。
set中的键不允许重复
第二类： 查找对应关系(键值对应)–dict
元素’a’出现了几次：dict–>字典
dict中的键不允许重复
第三类： 改变映射关系–map
通过将原有序列的关系映射统一表示为其他
Leetcode 349. 两个数组的交集
题目描述
给定两个数组，编写一个函数来计算它们的交集。
示例：
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]
说明：
输出结果中的每个元素一定是唯一的。
我们可以不考虑输出结果的顺序。
解题思路
由于每个元素只出现一次，因此不需要关注每个元素出现的次数，用set的数据结构就可以了。记录元素的有和无。
把nums1记录为set，判断nums2的元素是否在set中，是的话，就放在一个公共的set中，最后公共的set就是我们要的结果。
代码
class Solution:
def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
nums1 = set(nums1)
return set([i for i in nums2 if i in nums1])
Leetcode 350. 两个数组的交集 II
题目描述
给定两个数组，编写一个函数来计算它们的交集。
示例：
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]
说明：
输出结果中每个元素出现的次数，应与元素在两个数组中出现次数的最小值一致。
我们可以不考虑输出结果的顺序。
解题思路
对于存储次数就是有意义的，所以选择数据结构时，就应该选择dict的结构，通过字典的比较来判断；
记录每个元素的同时要记录这个元素的频次。
记录num1的字典，遍历nums2，比较nums1的字典的nums的key是否大于零，从而进行判断。
代码
class Solution:
def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
from collections import Counter
nums1_dict = Counter(nums1)
res = []
for num in nums2:
if nums1_dict[num] > 0:
# 说明找到了一个元素即在num1也在nums2
res.append(num)
nums1_dict[num] -= 1
return res
Leetcode 242. 有效的字母异位词
题目描述
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
示例：
输入: s = "anagram", t = "nagaram"
输出: true
说明:
你可以假设字符串只包含小写字母。
解题思路
不仅需要存储元素，还需要记录元素的个数。可以选择dict的数据结构，将字符串s和t都用dict存储，而后直接比较两个dict是否相同。
代码
class Solution:
def isAnagram(self, s: str, t: str) -> bool:
from collections import Counter
s = Counter(s)
t = Counter(t)
if s == t:
return True
else:
return False
Leetcode 202. 快乐数
题目描述
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为 1，那么这个数就是快乐数。
如果 n 是快乐数就返回 True ；不是，则返回 False 。
示例：
输入：19
输出：true
解释：
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1
解题思路
无限循环小数时有一个特征，就是当除的数中，和之前历史的得到的数有重合时，这时就是无限循环小数。
只需要判断有或无，不需要记录次数，故用set的数据结构。每次对求和的数进行append，当新一次求和的值存在于set中时，就return false.
代码
class Solution:
def isHappy(self, n: int) -> bool:
already = set()
while n != 1:
sum = 0
while n > 0:
# 取n的最后一位数
tmp = n % 10
sum += tmp ** 2
# 将n的最后一位截掉
n //= 10
# 如果求的和在过程中出现过
if sum in already:
return False
else:
already.add(sum)
n = sum
print(n)
return True
模板总结
#一般对多位数计算的套路是：
#循环从后向前取位数
while n >0 :
#取最后一位：
tmp = n % 10
#再截掉最后一位：
n = n // 10
Leetcode 290. 单词规律
题目描述
给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。
这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。
示例：
输入: pattern = "abba", str = "dog cat cat dog"
输出: true
输入:pattern = "abba", str = "dog cat cat fish"
输出: false
说明:
你可以假设 pattern 只包含小写字母， str 包含了由单个空格分隔的小写字母。
解题思路
抓住变与不变，变的是键，但是不变的是各个字典中，对应的相同index下的值，如dict1[index] = dict2[index]，那么我们可以创建两个新的字典，遍历index对两个新的字典赋值，并比较value。
还有一个思路比较巧妙，既然不同，那么可以考虑怎么让它们相同，将原来的dict通过map映射为相同的key，再比较相同key的dict是否相同。
代码
class Solution:
def wordPattern(self,pattern, str):
str = str.split() #因为str是字符串，不是由单个字符组成，所以开始需要根据空格拆成字符list
return list(map(pattern.index,pattern)) == list(map(str.index,str)) #通过map将字典映射为index的list
Leetcode 205. 同构字符串
题目描述
给定两个字符串 s 和 t，判断它们是否是同构的。
如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。
所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。
示例1：
输入: s = "egg", t = "add"
输出: true
示例2：
输入: s = "foo", t = "bar"
输出: false
解题思路
可以考虑通过建两个dict，比较怎样不同，也可以将不同转化为相同。
代码
class Solution:
def isIsomorphic(self, s: str, t: str) -> bool:
return list(map(s.index,s)) == list(map(t.index,t))
Leetcode 451. 根据字符出现频率排序
题目描述
给定一个字符串，请将字符串里的字符按照出现的频率降序排列。
示例：
输入:
"tree"
输出:
"eert"
示例2：
输入:
"cccaaa"
输出:
"cccaaa"
示例3：
输入:
"Aabb"
输出:
"bbAa"
解题思路
使用字典统计频率，对字典的value进行排序，最终根据key的字符串乘上value次数，组合在一起输出。
代码
class Solution:
def frequencySort(self, s: str) -> str:
from collections import Counter
s_dict = Counter(s)
# sorted返回的是列表元组
s = sorted(s_dict.items(), key=lambda item:item[1], reverse = True)
# 因为返回的是字符串
res = ''
for key, value in s:
res += key * value
return res
模板总结
通过sorted的方法进行value排序，对字典排序后无法直接按照字典进行返回，返回的为列表元组
# 对value值由大到小排序
s = sorted(s_dict.items(), key=lambda item:item[1], reverse = True)
# 对key由小到大排序
s = sorted(s_dict.items(), key=lambda item:item[0])
对撞指针
Leetcode 1. 两数之和
题目描述
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例：
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
解题思路
因为问题本身不是有序的，因此需要对原来的数组进行一次排序，排序后就可以用O(n)的指针对撞进行解决。
在排序前先使用一个额外的数组拷贝一份原来的数组，对于两个相同元素的索引问题，使用一个bool型变量辅助将两个索引都找到，总的时间复杂度为O(n)+O(nlogn) = O(nlogn)
代码
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
record = dict()
nums_copy = nums.copy()
sameFlag = True;
nums.sort()
l,r = 0,len(nums)-1
while l < r:
if nums[l] + nums[r] == target:
break
elif nums[l] + nums[r] < target:
l += 1
else:
r -= 1
res = []
for i in range(len(nums)):
if nums_copy[i] == nums[l] and sameFlag:
res.append(i)
sameFlag = False
elif nums_copy[i] == nums[r]:
res.append(i)
return res
Leetcode 15. 三数之和
题目描述
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例：
给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]
解题思路
开始时对nums数组进行排序，排序后，当第一次遍历的指针k遇到下一个和前一个指向的值重复时，就将其跳过。为了方便计算，在第二层循环中，可以使用对撞指针的套路：
# 对撞指针套路
l,r = 0, len(nums)-1
while l < r:
if nums[l] + nums[r] == target:
return nums[l],nums[r]
elif nums[l] + nums[r] < target:
l += 1
else:
r -= 1
其中需要注意的是，在里层循环中，也要考虑重复值的情况，因此当值相等时，再次移动指针时，需要保证其指向的值和前一次指向的值不重复，因此可以：
# 对撞指针套路
l,r = 0, len(nums)-1
while l < r:
sum = nums[i] + nums[l] + nums[r]
if sum == target:
res.append([nums[i],nums[l],nums[r])
l += 1
r -= 1
while l < r and nums[l] == nums[l-1]: l += 1
while l < r and nums[r] == nums[r+1]: r -= 1
elif sum < target:
l += 1
else:
r -= 1
再调整下遍历的范围，因为设了3个索引：i，l，r。边界情况下，r索引指向len-1, l指向len-2，索引i遍历的边界为len-3，故for循环是从0到len-2。
代码
class Solution:
def threeSum(self, nums: [int]) -> [[int]]:
nums.sort()
res = []
for i in range(len(nums)-2):
# 因为是排序好的数组，如果最小的都大于0可以直接排除
if nums[i] > 0: break
# 排除i的重复值
if i > 0 and nums[i] == nums[i-1]: continue
l,r = i+1, len(nums)-1
while l < r:
sum = nums[i] + nums[l] + nums[r]
if sum == 0:
res.append([nums[i],nums[l],nums[r]])
l += 1
r -= 1
while l < r and nums[l] == nums[l-1]: l += 1
while l < r and nums[r] == nums[r+1]: r -= 1
elif sum < 0:
l += 1
else:
r -= 1
return res
模板总结
对撞指针套路：
# 对撞指针套路
l,r = 0, len(nums)-1
while l < r:
if nums[l] + nums[r] == target:
return nums[l],nums[r]
elif nums[l] + nums[r] < target:
l += 1
else:
r -= 1
处理重复值的套路：先转换为有序数组，再循环判断其与上一次值是否重复：
# 1.
for i in range(len(nums)):
if i > 0 and nums[i] == nums[i-1]: continue
# 2.
while l < r:
while l < r and nums[l] == nums[l-1]: l += 1
Leetcode 18. 四数之和
题目描述
给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
示例：
给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。
满足要求的四元组集合为：
[
[-1, 0, 0, 1],
[-2, -1, 1, 2],
[-2, 0, 0, 2]
]
解题思路
首先排序。接着从[0,len-1]遍历i，跳过i的重复元素，再在[i+1,len-1]中遍历j，得到i，j后，再选择首尾的l和r，通过对撞指针的思路，四数和大的话r–，小的话l++,相等的话纳入结果list，最后返回。
套用3Sum得代码，在其前加一层循环，对边界情况进行改动即可:
- 原来3个是到len-2,现在外层循环是到len-3;
- 在中间层得迭代中，当第二个遍历得值在第一个遍历得值之后且后项大于前项时，认定为重复；
- 加些边界条件判断：当len小于4时，直接返回；当只有4个值且长度等于target时，直接返回本身即可。
代码
class Solution:
def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
nums.sort()
res = []
if len(nums) < 4: return res
if len(nums) == 4 and sum(nums) == target:
res.append(nums)
return res
for i in range(len(nums)-3):
if i > 0 and nums[i] == nums[i-1]: continue
for j in range(i+1,len(nums)-2):
if j > i+1 and nums[j] == nums[j-1]: continue
l,r = j+1, len(nums)-1
while l < r:
sum_value = nums[i] + nums[j] + nums[l] + nums[r]
if sum_value == target:
res.append([nums[i],nums[j],nums[l],nums[r]])
l += 1
r -= 1
while l < r and nums[l] == nums[l-1]: l += 1
while l < r and nums[r] == nums[r+1]: r -= 1
elif sum_value < target:
l += 1
else:
r -= 1
return res
Leetcode 16. 最接近的三数之和
题目描述
给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。
示例：
输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
解题思路
开始时可以随机设定一个三个数的和为结果值，在每次比较中，先判断三个数的和是否和target相等，如果相等直接返回和。如果不相等，则判断三个数的和与target的差是否小于这个结果值时，如果小于则进行则进行替换，并保存和的结果值。
代码
class Solution:
def threeSumClosest(self, nums: List[int], target: int) -> int:
nums.sort()
diff = abs(nums[0]+nums[1]+nums[2]-target)
res = nums[0] + nums[1] + nums[2]
for i in range(len(nums)):
l,r = i+1,len(nums)-1
t = target - nums[i]
while l < r:
if nums[l] + nums[r] == t:
return nums[i] + t
else:
if abs(nums[l]+nums[r]-t) < diff:
diff = abs(nums[l]+nums[r]-t)
res = nums[i]+nums[l]+nums[r]
if nums[l]+nums[r] < t:
l += 1
else:
r -= 1
return res
Leetcode 454. 四数相加 II
题目描述
给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。
为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500
示例：
输入:
A = [ 1, 2]
B = [-2,-1]
C = [-1, 2]
D = [ 0, 2]
输出:
2
解释:
两个元组如下:
1. (0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0
解题思路
首先可以考虑把D数组中的元素都放入查找表，然后遍历前三个数组，判断target减去每个元素后的值是否在查找表中存在，存在的话，把结果值加1。
那么查找表的数据结构选择用set还是dict？考虑到数组中可能存在重复的元素，而重复的元素属于不同的情况，因此用dict存储，最后的结果值加上dict相应key的value。
如果只遍历两个数组，那么就可以得到O(n^2)级别的算法，但是遍历两个数组，那么还剩下C和D两个数组，上面的值怎么放？可以通过dict来记录其中和的个数，之后遍历结果在和中进行查找。
代码
class Solution:
def fourSumCount(self, A: List[int], B: List[int], C: List[int], D: List[int]) -> int:
from collections import Counter
record = Counter()
for i in range(len(A)):
for j in range(len(B)):
record[A[i]+B[j]] += 1
res = 0
for i in range(len(C)):
for j in range(len(D)):
find_num = 0 - C[i] - D[j]
if record.get(find_num) != None:
res += record[find_num]
return res
优化：
class Solution:
def fourSumCount(self, A: List[int], B: List[int], C: List[int], D: List[int]) -> int:
record = collections.Counter(a + b for a in A for b in B)
return sum(record.get(- c - d, 0) for c in C for d in D)
Leetcode 49. 字母异位词分组
题目描述
给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。
示例：
输入: ["eat", "tea", "tan", "ate", "nat", "bat"],
输出:[["ate","eat","tea"],["nat","tan"],["bat"]]
说明：
所有输入均为小写字母。
不考虑答案输出的顺序。
解题思路
不同组的判断条件，就可以用数据结构dict中的key来代表，那么什么相同的适合当作key呢？
显然，如果将字符串统一排序，异位词排序后的字符串，显然都是相同的。那么就可以把其当作key，把遍历的数组中的异位词当作value，对字典进行赋值，进而遍历字典的value，得到结果list。
需要注意的细节是，字符串和list之间的转换：
默认构造字典需为list的字典；
排序使用sorted()函数，而不用list.sort()方法，因为其不返回值；
通过''.join(list)，将list转换为字符串；
通过str.split(',')将字符串整个转换为list中的一项；
代码
class Solution:
def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
from collections import defaultdict
strs_dict = defaultdict(list)
res = []
for str in strs:
key = ''.join(sorted(list(str)))
strs_dict[key] += str.split(',')
for v in strs_dict.values():
res.append(v)
return res
再将能用列表生成式替换的地方替换掉,代码实现如下：
class Solution:
def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
from collections import defaultdict
strs_dict = defaultdict(list)
for str in strs:
key = ''.join(sorted(list(str)))
strs_dict[key] += str.split(',')
return [v for v in strs_dict.values()]
Leetcode 447. 回旋镖的数量
题目描述
给定平面上 n 对不同的点，“回旋镖” 是由点表示的元组 (i, j, k) ，其中 i 和 j 之间的距离和 i 和 k 之间的距离相等（需要考虑元组的顺序）。
找到所有回旋镖的数量。你可以假设 n 最大为 500，所有点的坐标在闭区间 [-10000, 10000] 中。
示例：
输入:[[0,0],[1,0],[2,0]]
输出:2
解释:两个回旋镖为 [[1,0],[0,0],[2,0]] 和 [[1,0],[2,0],[0,0]]
解题思路
当i,j两点距离等于i,k时，用查找表的思路，等价于：对距离key(i,j或i,k的距离)，其值value(个数)为2。
那么就可以做一个查找表，用来查找相同距离key的个数value是多少。遍历每一个节点i，扫描得到其他点到节点i的距离，在查找表中，对应的键就是距离的值，对应的值就是距离值的个数。
在拿到对于元素i的距离查找表后，接下来就是排列选择问题了：
如果当距离为x的值有2个时，那么选择j,k的可能情况有：第一次选择有2种，第二次选择有1种，为2*1；
如果当距离为x的值有3个时，那么选择j,k的可能的情况有：第一次选择有3种，第二次选择有2种，为3*2;
那么当距离为x的值有n个时，选择j,k的可能情况有：第一次选择有n种，第二次选择有n-1种。
对于距离值的求算，按照欧式距离的方法进行求算的话，容易产生浮点数，可以将根号去掉，用差的平方和来进行比较距离。
代码
class Solution:
def numberOfBoomerangs(self, points: List[List[int]]) -> int:
res = 0
from collections import Counter
for i in points:
record = Counter()
for j in points:
if i != j:
record[self.dis(i,j)] += 1
for k,v in record.items():
res += v*(v-1)
return res
def dis(self,point1,point2):
return (point1[0]-point2[0]) ** 2 + (point1[1]-point2[1]) ** 2
对实现的代码进行优化：
将for循环遍历改为列表生成式;
对sum+=的操作，考虑使用sum函数。
对不同的函数使用闭包的方式内嵌；
class Solution:
def numberOfBoomerangs(self, points: List[List[int]]) -> int:
from collections import Counter
def f(x1, y1):
# 对一个i下j,k的距离值求和
d = Counter((x2 - x1) ** 2 + (y2 - y1) ** 2 for x2, y2 in points)
return sum(t * (t-1) for t in d.values())
# 对每个i的距离进行求和
return sum(f(x1, y1) for x1, y1 in points)
Leetcode 149. 直线上最多的点数
题目描述
给定一个二维平面，平面上有 n 个点，求最多有多少个点在同一条直线上。
示例：
输入: [[1,1],[2,2],[3,3]]
输出: 3
解释:
^
|
| o
| o
| o
+------------->
0 1 2 3 4
解题思路
判断点是否在一条直线上，其实就等价于判断i,j两点的斜率是否等于i,k两点的斜率。
直接考虑使用查找表实现，即查找相同斜率key的个数value是多少。
如果有两个斜率相同时，返回的应该是3个点，故返回的是结果数+1。
代码
class Solution:
def maxPoints(self,points):
if len(points) <= 1: #对边界情况进行判断，如果初始长度小于等于1,则直接返回len
return len(points)
res = 0
from collections import defaultdict
for i in range(len(points)):
record = defaultdict(int)
samepoint = 0 #对相同元素的情况单独考虑
for j in range(len(points)):
if points[i][0] == points[j][0] and points[i][1] == points[j][1]:
samepoint += 1
else:
record[self.get_Slope(points,i,j)] += 1
for v in record.values():
res = max(res, v+samepoint)
res = max(res, samepoint)
return res
def get_Slope(self,points,i,j): #直线为垂直的情况
if points[i][1] - points[j][1] == 0:
return float('Inf')
else:
return (points[i][0] - points[j][0]) / (points[i][1] - points[j][1])
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
