#2
class Solution(object):
def addTwoNumbers(self, l1, l2):
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
temp = ListNode(0)
res = temp
add = 0
while l1 or l2:
tsum = add
if l1:
tsum = tsum+l1.val
l1 = l1.next
if l2:
tsum = tsum+l2.val
l2 = l2.next
add = int(tsum/10) #这个add有点像进位的意思
temp.next = ListNode(tsum%10)
temp = temp.next
if add != 0:
temp.next = ListNode(add)
return res.next
#3 wu chongfu str max sybstr len
class Solution(object):
def lengthOfLongestSubstring(self, s):
"""
:type s: str
:rtype: int
"""
max_len = 0
if s is None or len(s) == 0:
return max_len
str_dict = {}
one_max = 0
start = 0
for i in range(len(s)):
if s[i] in str_dict and str_dict[s[i]] >= start:
start = str_dict[s[i]] + 1
one_max = i - start + 1
str_dict[s[i]] = i
max_len = max(max_len, one_max)
return max_len
#5
class Solution:
def expandAroundCenter(self, s, left, right):
while left >= 0 and right < len(s) and s[left] == s[right]:
left -= 1
right += 1
return left + 1, right - 1
def longestPalindrome(self, s: str) -> str:
start, end = 0, 0
for i in range(len(s)):
left1, right1 = self.expandAroundCenter(s, i, i)
left2, right2 = self.expandAroundCenter(s, i, i + 1)
if right1 - left1 > end - start:
start, end = left1, right1
if right2 - left2 > end - start:
start, end = left2, right2
return s[start: end + 1]
#11
class Solution:
def maxArea(self, height: List[int]) -> int:
l,r = 0,len(height) - 1
ans = 0
while l < r:
area = min(height[l],height[r])*(r - l)
ans = max(ans,area)
if height[l] <= height[r]:
l += 1
else:
r -= 1
return ans
#15 three num sum 0
class Solution:
def threeSum(self, nums: List[int]) -> List[List[int]]:
n=len(nums)
res=[]
if(not nums or n<3):
return []
nums.sort()
res=[]
for i in range(n):
if(nums[i]>0):
return res
if(i>0 and nums[i]==nums[i-1]):
continue
L=i+1
R=n-1
while(L<R):
if(nums[i]+nums[L]+nums[R]==0):
res.append([nums[i],nums[L],nums[R]])
while(L<R and nums[L]==nums[L+1]):
L=L+1
while(L<R and nums[R]==nums[R-1]):
R=R-1
L=L+1
R=R-1
elif(nums[i]+nums[L]+nums[R]>0):
R=R-1
else:
L=L+1
return res
#17 phone number arry
class Solution(object):
def letterCombinations(self, digits):
"""
:type digits: str
:rtype: List[str]
"""
dic = {2: ['a', 'b', 'c'],
3: ['d', 'e', 'f'],
4: ['g', 'h', 'i'],
5: ['j', 'k', 'l'],
6: ['m', 'n', 'o'],
7: ['p', 'q', 'r', 's'],
8: ['t', 'u', 'v'],
9: ['w', 'x', 'y', 'z'],
}
# 存储结果的数组
ret_str = []
if len(digits) == 0: return []
# 递归出口，当递归到最后一个数的时候result拿到结果进行for循环遍历
if len(digits) == 1:
return dic[int(digits[0])]
# 递归调用
result = self.letterCombinations(digits[1:])
# result是一个数组列表，遍历后字符串操作，加入列表
for r in result:
for j in dic[int(digits[0])]:
ret_str.append(j + r)
return ret_str
#19
class Solution:
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
dummy = ListNode(0, head)
first = head
second = dummy
for i in range(n):
first = first.next
while first:
first = first.next
second = second.next
second.next = second.next.next
return dummy.next
#22 shengchen kuohao
class Solution(object):
def generateParenthesis(self, n):
"""
:type n: int
:rtype: List[str]
"""
self.res = []
self.generateParenthesisIter('',n, n)
return self.res
def generateParenthesisIter(self, mstr, r, l):
if r ==0 and l==0:
self.res.append(mstr)
if l>0:
self.generateParenthesisIter(mstr+'(',r,l-1)
if r>0 and r>l:
self.generateParenthesisIter(mstr+')',r-1,l)
#31
class Solution:
def nextPermutation(self, nums: List[int]) -> None:
i = len(nums) - 2
while i >= 0 and nums[i] >= nums[i + 1]:
i -= 1
if i >= 0:
j = len(nums) - 1
while j >= 0 and nums[i] >= nums[j]:
j -= 1
nums[i], nums[j] = nums[j], nums[i]
left, right = i + 1, len(nums) - 1
while left < right:
nums[left], nums[right] = nums[right], nums[left]
left += 1
right -= 1
#33
class Solution:
def search(self, nums: List[int], target: int) -> int:
if not nums:
return -1
l, r = 0, len(nums) - 1
while l <= r:
mid = (l + r) // 2
if nums[mid] == target:
return mid
if nums[0] <= nums[mid]:
if nums[0] <= target < nums[mid]:
r = mid - 1
else:
l = mid + 1
else:
if nums[mid] < target <= nums[len(nums) - 1]:
l = mid + 1
else:
r = mid - 1
return -1
#34 find target the first and last poision in nums
class Solution:
def searchRange(self, nums: List[int], target: int) -> List[int]:
if target not in nums:
return [-1,-1]
res = [index for index,val in enumerate(nums) if val == target]
return [res[0], res[0]] if len(res)==1 else [res[0], res[-1]]
#39 in candidates = [2,3,5], target = 8 out [[2,2,2,2],[2,3,3],[3,5]]
from typing import List
class Solution:
def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
def dfs(candidates, begin, size, path, res, target):
if target < 0:
return
if target == 0:
res.append(path)
return
for index in range(begin, size):
dfs(candidates, index, size, path + [candidates[index]], res, target - candidates[index])
size = len(candidates)
if size == 0:
return []
path = []
res = []
dfs(candidates, 0, size, path, res, target)
return res
#46 quan pailie
class Solution(object):
def permute(self, nums):
"""
:type nums: List[int]
:rtype: List[List[int]]
"""
res = []
def back(nums_all,temp):
if len(nums_all) == 0:
res.append(temp)
for i in range(len(nums_all)):
back(nums_all[:i]+nums_all[i+1:],temp+[nums_all[i]])
t = []
back(nums,t)
return res
#48
class Solution:
def rotate(self, matrix: List[List[int]]) -> None:
"""
Do not return anything, modify matrix in-place instead.
"""
for i in range(len(matrix)):
for j in range(i,len(matrix)):
if i != j:
matrix[i][j],matrix[j][i] = matrix[j][i],matrix[i][j]
for i in range(len(matrix)):
matrix[i][:] = matrix[i][::-1]
#49 in strs = ["eat", "tea", "tan", "ate", "nat", "bat"] out [["bat"],["nat","tan"],["ate","eat","tea"]]
class Solution:
def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
dic = {}
for x in strs:
sorted_x = "".join(sorted(x))
if sorted_x in dic:
dic[sorted_x].append(x)
else:
dic[sorted_x] = [x]
return list(dic.values())
class Solution:
def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
mp = collections.defaultdict(list)
for st in strs:
key = "".join(sorted(st))
mp[key].append(st)
return list(mp.values())
#55
class Solution:
def canJump(self, nums: List[int]) -> bool:
n, rightmost = len(nums), 0
for i in range(n):
if i <= rightmost:
rightmost = max(rightmost, i + nums[i])
if rightmost >= n - 1:
return True
return False
#56 merge range
class Solution:
def merge(self, intervals: List[List[int]]) -> List[List[int]]:
intervals.sort(key=lambda x: x[0])
merged = []
for interval in intervals:
# 如果列表为空，或者当前区间与上一区间不重合，直接添加
if not merged or merged[-1][1] < interval[0]:
merged.append(interval)
else:
# 否则的话，我们就可以与上一区间进行合并
merged[-1][1] = max(merged[-1][1], interval[1])
return merged
#62 m*n down or right
class Solution(object):
def uniquePaths(self, m, n):
"""
:type m: int
:type n: int
:rtype: int
"""
if m == 1 or n == 1:
return 1
dp = [[1 for _ in range(n)] for _ in range(m)]
for i in range(1,m):
for j in range(1,n):
dp[i][j] = dp[i-1][j] + dp[i][j-1]
return dp[m-1][n-1]
#64
class Solution:
def minPathSum(self, grid: List[List[int]]) -> int:
if not grid or not grid[0]:
return 0
rows, columns = len(grid), len(grid[0])
dp = [[0] * columns for _ in range(rows)]
dp[0][0] = grid[0][0]
for i in range(1, rows):
dp[i][0] = dp[i - 1][0] + grid[i][0]
for j in range(1, columns):
dp[0][j] = dp[0][j - 1] + grid[0][j]
for i in range(1, rows):
for j in range(1, columns):
dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]
return dp[rows - 1][columns - 1]
#75
class Solution:
def sortColors(self, nums: List[int]) -> None:
#0 1 2 not sort
n = len(nums)
ptr = 0
for i in range(n):
if nums[i] == 0:
nums[i], nums[ptr] = nums[ptr], nums[i]
ptr += 1
for i in range(ptr, n):
if nums[i] == 1:
nums[i], nums[ptr] = nums[ptr], nums[i]
ptr += 1
#78
class Solution(object):
def subsets(self, nums):
"""
:type nums: List[int]
:rtype: List[List[int]]
"""
output = [[]]
for i in range(len(nums)):
for j in range(len(output)):
output.append(output[j]+[nums[i]])
return output
#79 word search
class Solution:
def exist(self, board: List[List[str]], word: str) -> bool:
r, c = len(board), len(board[0])
ans = []
for i in range(r):
for j in range(c):
if board[i][j] == word[0]:
if self.dfs(board, i, j, word): return True
return False
def dfs(self, tmp, i, j, word):
#如果word不存在则返回True
if not word: return True
#如果word不在范围内也返回False
if not (i>=0 and i <len(tmp)) or not (j>=0 and j<len(tmp[0])):
return False
#如果tmp在i，j处得值不等于word的第一个值，则返回False
if not tmp[i][j] == word[0]: return False
tmp[i][j] += ' '
res = self.dfs(tmp, i+1, j, word[1:]) or \
self.dfs(tmp, i-1, j, word[1:]) or \
self.dfs(tmp, i, j+1, word[1:]) or \
self.dfs(tmp, i, j-1, word[1:])
tmp[i][j] = tmp[i][j][:-1]
return res
#96
class Solution:
def numTrees(self, n):
"""
:type n: int
:rtype: int
"""
G = [0]*(n+1)
G[0], G[1] = 1, 1
for i in range(2, n+1):
for j in range(1, i+1):
G[i] += G[j-1] * G[i-j]
return G[n]
#98
class Solution(object):
def isValidBST(self, root):
"""
:type root: TreeNode
:rtype: bool
"""
inorder = self.inorder(root)
return inorder == list(sorted(set(inorder)))
def inorder(self,root):
if not root:return []
return self.inorder(root.left)+[root.val]+self.inorder(root.right)
#102
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def levelOrder(self, root):
"""
:type root: TreeNode
:rtype: List[List[int]]
"""
queue = [root]
res = []
if not root:
return []
while queue:
templist = []
templen =len(queue)
for i in range(templen):
temp = queue.pop(0)
templist.append(temp.val)
if temp.left:
queue.append(temp.left)
if temp.right:
queue.append(temp.right)
res.append(templist)
return res
#105 from qian and mid to build hou
class Solution:
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
def myBuildTree(preorder_left: int, preorder_right: int, inorder_left: int, inorder_right: int):
if preorder_left > preorder_right:
return None
preorder_root = preorder_left
inorder_root = index[preorder[preorder_root]]
root = TreeNode(preorder[preorder_root])
size_left_subtree = inorder_root - inorder_left
root.left = myBuildTree(preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 1)
root.right = myBuildTree(preorder_left + size_left_subtree + 1, preorder_right, inorder_root + 1, inorder_right)
return root
n = len(preorder)
index = {element: i for i, element in enumerate(inorder)}
return myBuildTree(0, n - 1, 0, n - 1)
#114 tree to listnode
class Solution:
def flatten(self, root: TreeNode) -> None:
preorderList = list()
def preorderTraversal(root: TreeNode):
if root:
preorderList.append(root)
preorderTraversal(root.left)
preorderTraversal(root.right)
preorderTraversal(root)
size = len(preorderList)
for i in range(1, size):
prev, curr = preorderList[i - 1], preorderList[i]
prev.left = None
prev.right = curr
class Solution:
def flatten(self, root: TreeNode) -> None:
preorderList = list()
stack = list()
node = root
while node or stack:
while node:
preorderList.append(node)
stack.append(node)
node = node.left
node = stack.pop()
node = node.right
size = len(preorderList)
for i in range(1, size):
prev, curr = preorderList[i - 1], preorderList[i]
prev.left = None
prev.right = curr
#128 maxlen lianxu xulie in [100,4,200,1,3,2] out 4 [1,2,3,4]
class Solution:
def longestConsecutive(self, nums: List[int]) -> int:
longest_streak = 0
num_set = set(nums)
for num in num_set:
if num - 1 not in num_set:
current_num = num
current_streak = 1
while current_num + 1 in num_set:
current_num += 1
current_streak += 1
longest_streak = max(longest_streak, current_streak)
return longest_streak
#139
class Solution:
def wordBreak(self, s: str, wordDict: List[str]) -> bool:
n=len(s)
dp=[False]*(n+1)
dp[0]=True
for i in range(n):
for j in range(i+1,n+1):
if(dp[i] and (s[i:j] in wordDict)):
dp[j]=True
return dp[-1]
#142 huanxing listnode 2
class Solution(object):
def detectCycle(self, head):
fast, slow = head, head
while True:
if not (fast and fast.next): return
fast, slow = fast.next.next, slow.next
if fast == slow: break
fast = head
while fast != slow:
fast, slow = fast.next, slow.next
return fast
#146
class LRUCache(collections.OrderedDict):
def __init__(self, capacity: int):
super().__init__()
self.capacity = capacity
def get(self, key: int) -> int:
if key not in self:
return -1
self.move_to_end(key)
return self[key]
def put(self, key: int, value: int) -> None:
if key in self:
self.move_to_end(key)
self[key] = value
if len(self) > self.capacity:
self.popitem(last=False)
#148
class Solution:
def sortList(self, head: ListNode) -> ListNode:
if not head or not head.next: return head # termination.
# cut the LinkedList at the mid index.
slow, fast = head, head.next
while fast and fast.next:
fast, slow = fast.next.next, slow.next
mid, slow.next = slow.next, None # save and cut.
# recursive for cutting.
left, right = self.sortList(head), self.sortList(mid)
# merge `left` and `right` linked list and return it.
h = res = ListNode(0)
while left and right:
if left.val < right.val: h.next, left = left, left.next
else: h.next, right = right, right.next
h = h.next
h.next = left if left else right
return res.next
#152 数组中乘积最大的非空连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。
class Solution:
def maxProduct(self, nums: List[int]) -> int:
if(len(nums)==1):return nums[0]
posmax,negmax=0,0 #正最大和负最大
result=nums[0]
for i in range(len(nums)):
tempPosmax=posmax
tempNegmax=negmax
posmax=max(nums[i],max(nums[i]*tempPosmax,nums[i]*tempNegmax))
negmax=min(nums[i],min(nums[i]*tempPosmax,nums[i]*tempNegmax))
result=max(result,posmax)
return result
#198 in [1,2,3,1] out 4
class Solution:
def rob(self, nums: List[int]) -> int:
if not nums:
return 0
size = len(nums)
if size == 1:
return nums[0]
dp = [0] * size
dp[0] = nums[0]
dp[1] = max(nums[0], nums[1])
for i in range(2, size):
dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])
return dp[size - 1]
class Solution:
def rob(self, nums: List[int]) -> int:
last = 0
now = 0
for i in nums:
last, now = now, max(last + i, now)
return now
#200
class Solution:
def dfs(self, grid, r, c):
grid[r][c] = 0
nr, nc = len(grid), len(grid[0])
for x, y in [(r - 1, c), (r + 1, c), (r, c - 1), (r, c + 1)]:
if 0 <= x < nr and 0 <= y < nc and grid[x][y] == "1":
self.dfs(grid, x, y)
def numIslands(self, grid: List[List[str]]) -> int:
nr = len(grid)
if nr == 0:
return 0
nc = len(grid[0])
num_islands = 0
for r in range(nr):
for c in range(nc):
if grid[r][c] == "1":
num_islands += 1
self.dfs(grid, r, c)
return num_islands
#207 kechengbiao in numCourses = 2, prerequisites = [[1,0],[0,1]] out false
class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
edges = collections.defaultdict(list)
indeg = [0] * numCourses
for info in prerequisites:
edges[info[1]].append(info[0])
indeg[info[0]] += 1
q = collections.deque([u for u in range(numCourses) if indeg[u] == 0])
visited = 0
while q:
visited += 1
u = q.popleft()
for v in edges[u]:
indeg[v] -= 1
if indeg[v] == 0:
q.append(v)
return visited == numCourses
#208
class Trie:
def __init__(self):
self.children = [None] * 26
self.isEnd = False
def searchPrefix(self, prefix: str) -> "Trie":
node = self
for ch in prefix:
ch = ord(ch) - ord("a")
if not node.children[ch]:
return None
node = node.children[ch]
return node
def insert(self, word: str) -> None:
node = self
for ch in word:
ch = ord(ch) - ord("a")
if not node.children[ch]:
node.children[ch] = Trie()
node = node.children[ch]
node.isEnd = True
def search(self, word: str) -> bool:
node = self.searchPrefix(word)
return node is not None and node.isEnd
def startsWith(self, prefix: str) -> bool:
return self.searchPrefix(prefix) is not None
#215
class Solution:
def findKthLargest(self, nums: List[int], k: int) -> int:
new_list = sorted(nums)
return new_list[-k]
#221
class Solution:
def maximalSquare(self, matrix: List[List[str]]) -> int:
if len(matrix) == 0 or len(matrix[0]) == 0:
return 0
maxSide = 0
rows, columns = len(matrix), len(matrix[0])
dp = [[0] * columns for _ in range(rows)]
for i in range(rows):
for j in range(columns):
if matrix[i][j] == '1':
if i == 0 or j == 0:
dp[i][j] = 1
else:
dp[i][j] = min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1
maxSide = max(maxSide, dp[i][j])
maxSquare = maxSide * maxSide
return maxSquare
#236
class Solution:
def lowestCommonAncestor(self, root: TreeNode, p: TreeNode, q: TreeNode) -> TreeNode:
if not root or root == p or root == q: return root
left = self.lowestCommonAncestor(root.left, p, q)
right = self.lowestCommonAncestor(root.right, p, q)
if not left: return right
if not right: return left
return root
#238
class Solution:
def productExceptSelf(self, nums: List[int]) -> List[int]:
length = len(nums)
L, R, answer = [0]*length, [0]*length, [0]*length
L[0] = 1
for i in range(1, length):
L[i] = nums[i - 1] * L[i - 1]
R[length - 1] = 1
for i in reversed(range(length - 1)):
R[i] = nums[i + 1] * R[i + 1]
for i in range(length):
answer[i] = L[i] * R[i]
return answer
#240
class Solution:
def searchMatrix(self, matrix, target):
"""
:type matrix: List[List[int]]
:type target: int
:rtype: bool
"""
n = len(matrix)
if n == 0:
return False
m = len(matrix[0])
if m == 0:
return False
i = 0
j = m -1
while i < n and j >=0:
if matrix[i][j]>target:
j = j-1
elif matrix[i][j]<target:
i = i+1
else:
return True
return False
#279
class Solution:
def numSquares(self, n):
if n <= 3:
return n
dp = [0]*(n+1)
dp[1] = dp[2] = dp[3] = 1
square_nums = [i*i for i in range(1,int(n**0.5)+1)]
for i in range(1,n+1):
tmp = []
for num in square_nums:
if i - num < 0:
break
tmp.append(dp[i-num])
dp[i] = min(tmp)+1
return dp[n]
#287 only occur one and one num
class Solution:
def findDuplicate(self, nums: List[int]) -> int:
nums_set = set()
for num in nums:
if num in nums_set:
return num
else:
nums_set.add(num)
or huanxinglianbiao
#300 in [10,9,2,5,3,7,101,18] out 4 zuichangdizengzixulie 2 3 7 101
class Solution:
def lengthOfLIS(self, nums: List[int]) -> int:
if not nums:
return 0
dp = []
for i in range(len(nums)):
dp.append(1)
for j in range(i):
if nums[i] > nums[j]:
dp[i] = max(dp[i], dp[j] + 1)
return max(dp)
# 1tian lengdongqi
class Solution:
def maxProfit(self, prices: List[int]) -> int:
if not prices:
return 0
n = len(prices)
# f[i][0]: 手上持有股票的最大收益
# f[i][1]: 手上不持有股票，并且处于冷冻期中的累计最大收益
# f[i][2]: 手上不持有股票，并且不在冷冻期中的累计最大收益
f = [[-prices[0], 0, 0]] + [[0] * 3 for _ in range(n - 1)]
for i in range(1, n):
f[i][0] = max(f[i - 1][0], f[i - 1][2] - prices[i])
f[i][1] = f[i - 1][0] + prices[i]
f[i][2] = max(f[i - 1][1], f[i - 1][2])
return max(f[n - 1][1], f[n - 1][2])
#322 coins = [1, 2, 5], amount = 11 out 3 5+5+1
class Solution:
def coinChange(self, coins: List[int], amount: int) -> int:
dp = [float('inf')] * (amount + 1)
dp[0] = 0
for coin in coins:
for x in range(coin, amount + 1):
dp[x] = min(dp[x], dp[x - coin] + 1)
return dp[amount] if dp[amount] != float('inf') else -1
#337 rob 3 tree
class Solution:
def rob(self, root: TreeNode) -> int:
def _rob(root):
if not root: return 0, 0
#ls rob left max profit
#ln not rob left max profit
ls, ln = _rob(root.left)
rs, rn = _rob(root.right)
return root.val + ln + rn, max(ls, ln) + max(rs, rn)
return max(_rob(root))
#347
class Solution:
def topKFrequent(self, nums: List[int], k: int) -> List[int]:
count = collections.Counter(nums)
return [item[0] for item in count.most_common(k)]
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
