leetcode-python 第六周

1.Combination Sum [208ms]

#方法1：dfs，适当剪枝
class Solution(object):
import copy
def combinationSum(self, candidates, target):
result = []
tmp = []
sorted(candidates)
self.dfs(0, tmp, result, candidates, target)
return result

def dfs(self, k, tmp, result, candidates, target) :
if k > len(candidates) :
return
if sum(tmp) > target :
return
elif sum(tmp) == target :
t = copy.deepcopy(tmp)
result.append(t)

for i in range(k, len(candidates)) :
tmp.append(candidates[i])
#这里传i到k可以避免重复
self.dfs(i, tmp, result, candidates, target)
del tmp[-1]

2.Contruct Binary Tree from Inorder and Postorder Traversal [128ms]

#方法1：类型跟前序中序类似，用索引而不用切片
class Solution(object):
def construct(self, inorder, istart, iend, postorder, pstart, pend) :
if istart > iend :
return None
else :
node = TreeNode(postorder[pend])
iroot = inorder.index(postorder[pend])
llen = iroot - istart
rlen = iend - iroot

left_istart = istart
left_iend = left_istart + llen - 1
left_pstart = pstart
left_pend = left_pstart + llen - 1

right_istart = iroot + 1
right_iend = right_istart + rlen - 1
right_pstart = left_pend + 1
right_pend = right_pstart + rlen - 1

node.left = self.construct(inorder, left_istart, left_iend, postorder, left_pstart, left_pend)
node.right = self.construct(inorder, right_istart, right_iend, postorder, right_pstart, right_pend)

return node

def buildTree(self, inorder, postorder):
return self.construct(inorder, 0, len(inorder)-1, postorder, 0, len(postorder)-1)

3.Construct Binary Tree from Preorder and Inorder Traversal

#方法1：递归，爆内存
#方法2：递归修改版，不用切片不然会爆Memery，用指针操作
def solution(preorder, inorder) :
if len(preorder) :
in_root = inorder.index(preorder[0])
in_left = inorder[:in_root]
in_right = inorder[in_root+1:]

pre_left = preorder[1:len(in_left)+1]
pre_right = preorder[1+len(in_left):]

header = TreeNode(preorder[0])
header.left = solution(pre_left, in_left)
header.right = solution(pre_right, in_right)
return header
else :
return

class Solution(object):
def construct(self, preorder, pstart, pend, inorder, istart, iend):
if pstart > pend:
return None
else:
header = TreeNode(preorder[pstart])
root = inorder.index(preorder[pstart])
llen = root - istart
rlen = iend - root

left_pstart = pstart + 1
left_pend = left_pstart + llen - 1
left_istart = istart
left_iend = left_istart + llen - 1

right_pstart = left_pend + 1
right_pend = right_pstart + rlen - 1
right_istart = root + 1
right_iend = right_istart + rlen - 1

header.left = self.construct(preorder, left_pstart, left_pend, inorder, left_istart, left_iend)
header.right = self.construct(preorder, right_pstart, right_pend, inorder, right_istart, right_iend)
return header

def buildTree(self, preorder, inorder):
return self.construct(preorder, 0, len(preorder)-1, inorder, 0, len(inorder)-1)

4.Maximum Subarry [68ms]

#方法1：参考网上的dp
#只有两种情况，要么加上前序列，要么另开
class Solution(object):
def maxSubArray(self, nums):
l = len(nums)
dp = [nums[i] for i in range(l)]
for i in range(1, l) :
dp[i] = max(dp[i-1] + nums[i], nums[i])
return max(dp)

5.Rotate Image [56ms]

#方法1：额外空间，ans的第一个坐标和matrix第二个坐标相加等于n [56ms]
#方法2: 四个位置相对变换，拿四个角操作就知道[56ms]
#方法3：先"/"对角线反转，再上下翻转
#
#总结：
#   [i, j] = [j, i]             "\"对角线
#   [i, j] = [n-1-j, n-1-i]     "/"对角线
#   [i, j] = [n-1-i, n-1-j]     "."中心点对称
class Solution(object):
def rotate(self, matrix):
n = len(matrix)
ans = [[0 for i in range(n)] for i in range(n)]
for i in range(n) :
for j in range(n) :
ans[j][n-1-i] = matrix[i][j]
for i in range(n) :
for j in range(n) :
matrix[i][j] = ans[i][j]

class Solution(object):
def rotate(self, matrix):
n = len(matrix)
half = int(n / 2)
for i in range(half+1):
for j in range(i, n-1-i):
tmp = matrix[i][j]
matrix[i][j] = matrix[n-1-j][i]
matrix[n-1-j][i] = matrix[n-1-i][n-1-j]
matrix[n-1-i][n-1-j] = matrix[j][n-1-i]
matrix[j][n-1-i] = tmp

class Solution(object):
def rotate(self, matrix):
n = len(matrix)
half = int(n / 2)
for i in range(n) :
for j in range(n-i) :
matrix[i][j], matrix[n-1-j][n-1-i] = matrix[n-1-j][n-1-i], matrix[i][j]
for i in range(half) :
for j in range(n) :
matrix[i][j], matrix[n-1-i][j] = matrix[n-1-i][j], matrix[i][j]

6.Search For a Range[48ms]

#方法1：条件 low < high - 1 会提供两个候选值
#分别判断就可以
class Solution(object):
def searchRange(self, nums, target) :
low, high = 0, len(nums) - 1

while low < high - 1 :
mid = int((low + high) / 2)
if nums[mid] == target :
high = mid
elif target < nums[mid] :
high = mid
else :
low = mid
if target == nums[low] :
left = low
elif target == nums[high] :
left = high
else :
left = -1

low, high = 0, len(nums) - 1
while low < high - 1 :
mid = int((low + high) / 2)
if nums[mid] == target :
low = mid
elif target < nums[mid] :
high = mid
else :
low = mid
if target == nums[high] :
right = high
elif target == nums[low] :
right = low
else :
right = -1

return [left, right]

7.Search Insert Position [52ms]

#方法1：二分搜索，因为搜不到low会加一，所以直接返回low
class Solution(object):
def searchInsert(self, nums, target):
low, high = 0, len(nums)
while low < high :
mid = int((low + high) / 2)
if nums[mid] == target :
return mid

if target < nums[mid] :
high = mid
else :
low = mid + 1
return low