目录
典型应用 1
Leetcode 35. 搜索插入位置1
from typing import List
class Solution:
def searchInsert(self, nums: List[int], target: int) -> int:
size = len(nums)
if size == 0:
return 0
# 特判
if nums[size - 1] < target:
return size
left = 0
right = size - 1
while left < right:
# left + right 在 Python 中如果发生整型溢出，Python 会自动转成长整形
mid = (left + right) // 2
# 严格小于 target 的元素一定不是解
if nums[mid] < target:
# 下一轮搜索区间是 [mid + 1, right]
left = mid + 1
else:
# 下一轮搜索区间是 [left, mid]
right = mid
return left
Leetcode 202. 快乐数2
def isHappy(self, n: int) -> bool:
cycle_members = {4, 16, 37, 58, 89, 145, 42, 20}
def get_next(number):
total_sum = 0
while number > 0:
number, digit = divmod(number, 10)
total_sum += digit ** 2
return total_sum
while n != 1 and n not in cycle_members:
n = get_next(n)
return n == 1
Leetcode 205. 同构字符串3
class Solution(object):
def isIsomorphic(self, s, t):
"""
:type s: str
:type t: str
:rtype: bool
"""
if not s:
return True
dic={}
for i in range(len(s)):
if s[i] not in dic:
if t[i] in dic.values():
return False
else:
dic[s[i]]=t[i]
else:
if dic[s[i]]!=t[i]:
return False
return True
Leetcode 242. 有效的字母异位词4
def isAnagram(self, s: str, t: str) -> bool:
# 定义默认布尔值参与后续运算
result = True
# 利用 Python 数据结构 set 去重去序
set_tmp = set(s)
# 先判断组成字符串的各个字符元素是否一致
if set_tmp == set(t):
for i in set_tmp:
# 利用逻辑运算符判断各个字符元素的数量一致，均为 True 才输出 True
result = result and (s.count(i) == t.count(i))
else:
result = False
return (result)
Leetcode 290. 单词规律5
class Solution {
public:
bool wordPattern(string pattern, string str) {
vector<string> vtr;
int t=-1;
for(int i=1;i<str.size();i++){//将str中的字符块保存到vtr中，方便使用索引
if(str[i]==' '){
t=t+1;
vtr.push_back(str.substr(t,i-t));
t=i;
}
}
vtr.push_back(str.substr(t+1,str.size()-1));//因为最后一个字符块后面没有空格符，所以最后单独加这一步
int n=pattern.size(),m=vtr.size();
if(n!=m) return false;//两个对应大小不等，直接返回false
map<char,int> map1;//记录pattern的关系
map<string,int> map2;//记录str（vtr）的关系
for(int i=0;i<n;i++) if(!map1[pattern[i]]) map1[pattern[i]]=i+1;//如果map1里面没有这个key，这将这个key与其索引值+1加入map1中
for(int i=0;i<m;i++) if(!map2[vtr[i]]) map2[vtr[i]]=i+1;//同理维护map2
for(int i=0;i<n;i++) if(map1[pattern[i]]!=map2[vtr[i]]) return false;//比较若key的对应值不相等，则说明不一一映射，返回false
return true;//所有的都满足，返回true
}
};
Leetcode 349. 两个数组的交集6
class Solution:
def set_intersection(self, set1, set2):
return [x for x in set1 if x in set2]
def intersection(self, nums1, nums2):
"""
:type nums1: List[int]
:type nums2: List[int]
:rtype: List[int]
"""
set1 = set(nums1)
set2 = set(nums2)
if len(set1) < len(set2):
return self.set_intersection(set1, set2)
else:
return self.set_intersection(set2, set1)
Leetcode 350. 两个数组的交集 II7
class Solution:
def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
if len(nums1) > len(nums2):
return self.intersect(nums2, nums1)
m = collections.Counter()
for num in nums1:
m[num] += 1
intersection = list()
for num in nums2:
if (count := m.get(num, 0)) > 0:
intersection.append(num)
m[num] -= 1
if m[num] == 0:
m.pop(num)
return intersection
典型应用 2
Leetcode 1. 两数之和8
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
hashset={}
for i in range(len(nums)):
if hashset.get(target-nums[i]) is not None :
return [hashset.get(target-nums[i]),i]
hashset[nums[i]]=i
Leetcode 15. 三数之和9
class Solution:
def threeSum(self, nums: List[int]) -> List[List[int]]:
n = len(nums)
nums.sort()
ans = list()
# 枚举 a
for first in range(n):
# 需要和上一次枚举的数不相同
if first > 0 and nums[first] == nums[first - 1]:
continue
# c 对应的指针初始指向数组的最右端
third = n - 1
target = -nums[first]
# 枚举 b
for second in range(first + 1, n):
# 需要和上一次枚举的数不相同
if second > first + 1 and nums[second] == nums[second - 1]:
continue
# 需要保证 b 的指针在 c 的指针的左侧
while second < third and nums[second] + nums[third] > target:
third -= 1
# 如果指针重合，随着 b 后续的增加
# 就不会有满足 a+b+c=0 并且 b<c 的 c 了，可以退出循环
if second == third:
break
if nums[second] + nums[third] == target:
ans.append([nums[first], nums[second], nums[third]])
return ans
Leetcode 16. 最接近的三数之和10
class Solution:
def threeSumClosest(self, nums: List[int], target: int) -> int:
nums.sort()
n = len(nums)
best = 10**7
# 根据差值的绝对值来更新答案
def update(cur):
nonlocal best
if abs(cur - target) < abs(best - target):
best = cur
# 枚举 a
for i in range(n):
# 保证和上一次枚举的元素不相等
if i > 0 and nums[i] == nums[i - 1]:
continue
# 使用双指针枚举 b 和 c
j, k = i + 1, n - 1
while j < k:
s = nums[i] + nums[j] + nums[k]
# 如果和为 target 直接返回答案
if s == target:
return target
update(s)
if s > target:
# 如果和大于 target，移动 c 对应的指针
k0 = k - 1
# 移动到下一个不相等的元素
while j < k0 and nums[k0] == nums[k]:
k0 -= 1
k = k0
else:
# 如果和小于 target，移动 b 对应的指针
j0 = j + 1
# 移动到下一个不相等的元素
while j0 < k and nums[j0] == nums[j]:
j0 += 1
j = j0
return best
总结
https://leetcode-cn.com/problems/search-insert-position/solution/te-bie-hao-yong-de-er-fen-cha-fa-fa-mo-ban-python-/ ↩︎
https://leetcode-cn.com/problems/happy-number/solution/kuai-le-shu-by-leetcode-solution/ ↩︎
https://leetcode-cn.com/problems/isomorphic-strings/solution/ha-xi-biao-ji-nian-di-yi-ci-shuang-bai-by-zyd-9/ ↩︎
https://leetcode-cn.com/problems/valid-anagram/solution/zhan-sheng-98de-python-jie-fa-by-reynard/ ↩︎
https://leetcode-cn.com/problems/word-pattern/solution/ha-xi-xiang-xi-zhu-shi-by-llllllll-9/ ↩︎
https://leetcode-cn.com/problems/intersection-of-two-arrays/solution/liang-ge-shu-zu-de-jiao-ji-by-leetcode/ ↩︎
https://leetcode-cn.com/problems/intersection-of-two-arrays-ii/solution/liang-ge-shu-zu-de-jiao-ji-ii-by-leetcode-solution/ ↩︎
https://leetcode-cn.com/problems/two-sum/solution/san-chong-fang-fa-bao-li-shuang-zhi-zhen-ha-xi-san/ ↩︎
https://leetcode-cn.com/problems/3sum/solution/san-shu-zhi-he-by-leetcode-solution/ ↩︎
https://leetcode-cn.com/problems/3sum-closest/solution/zui-jie-jin-de-san-shu-zhi-he-by-leetcode-solution/ ↩︎
扫一扫
329
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
