两数之和
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
nums=list(enumerate(nums))
nums.sort(key=lambda x:x[1])
l,r=0,len(nums)-1
while l<r:
if nums[l][1]+nums[r][1]==target:
return nums[l][0],nums[r][0]
elif nums[l][1]+nums[r][1]<target:
l+=1
else:
r-=1
三数之和
class Solution:
def threeSum(self, nums: List[int]) -> List[List[int]]:
nums.sort()
res=[]
for i in range(len(nums)-2):
if nums[i]>0:
bresk
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
四数之和
class Solution:
def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
nums.sort()
from itertools import combinations
res=[]
for i in combinations(nums,4):
if sum(i)==target:
res.append(i)
res=set(res)
return res
最接近的三数之和
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
四数相加II
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[i]
if record.get(find_num)!=None:
res+=record[find_num]
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()]
直线上最多的点数
class Solution:
def maxPoints(self, points: List[List[int]]) -> int:
if len(points)<=1:
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,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])
存在重复元素II
class Solution:
def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
dict = {}
for i in range(len(nums)):
if nums[i] in dict and i - dict[nums[i]] <= k:
return True
dict[nums[i]] = i
return False
存在重复元素III
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