leetcode-python 第六周

LeetCode Online Judge
https://leetcode.com/

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