python leetcode 301-310

# 302
class Solution:
    def minArea(self, image: List[List[str]], x: int, y: int) -> int:
        length = []
        width = []
        for i in range(len(image)):
            for j in range(len(image[0])):
                if image[i][j] == '1':
                    length.append(i)
                    width.append(j)
        return (max(length) - min(length) + 1) * (max(width) - min(width) + 1)

# 303
class NumArray:

    def __init__(self, nums: List[int]):
        self.sums = [0]
        _sums = self.sums

        for num in nums:
            _sums.append(_sums[-1] + num)

    def sumRange(self, i: int, j: int) -> int:
        _sums = self.sums
        return _sums[j + 1] - _sums[i]

# 304
class NumMatrix:

    def __init__(self, matrix: List[List[int]]):
        m, n = len(matrix), (len(matrix[0]) if matrix else 0)
        self.sums = [[0] * (n + 1) for _ in range(m)]
        _sums = self.sums

        for i in range(m):
            for j in range(n):
                _sums[i][j + 1] = _sums[i][j] + matrix[i][j]

    def sumRegion(self, row1: int, col1: int, row2: int, col2: int) -> int:
        _sums = self.sums

        total = sum(_sums[i][col2 + 1] - _sums[i][col1] for i in range(row1, row2 + 1))
        return total

# 306
class Solution:
    def isAdditiveNumber(self, num: str) -> bool:
        def isValid(sub1, sub2, num):
            if not num: return True
            sub1, sub2 = sub2, str(int(sub1) + int(sub2))
            return num.startswith(sub2) and isValid(sub1, sub2, num[len(sub2):])

        n = len(num)
        for i in range(1, n // 2 + 1):
            if num[0] == "0" and i > 1: return False
            sub1 = num[:i]
            for j in range(1, n):
                # 剩下的长度都没有前面两个数最大长度长
                if max(i, j) > n - i - j: break
                if num[i] == "0" and j > 1: break
                sub2 = num[i: i + j]
                # 找到两个数, 看后面的数是否能引出来
                if isValid(sub1, sub2, num[i + j:]): return True
        return False

# 309
class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if not prices:
            return 0
        n = len(prices)
        dp = [[0] * 3 for _ in range(n)]
        dp[0][0] = -prices[0]
        for i in range(1 , n):
            dp[i][0] = max(dp[i - 1][0] , dp[i - 1][2] - prices[i])
            dp[i][1] = max(dp[i - 1][1] , dp[i - 1][0] + prices[i])
            dp[i][2] = dp[i - 1][1]
        return dp[-1][1]

# 310
class Solution:
    def findMinHeightTrees(self, n: int, edges: List[List[int]]) -> List[int]:
        if n==1:
            return [0] # corner case
        adjacent=[set() for _ in range(n)]
        for u,v in edges: # create adjacent list for each node, and save them in corresponding set, for example, set0 save all the nodes that conneted to node 0
            adjacent[u].add(v)
            adjacent[v].add(u)
        leaves=[]
        for i in range(len(adjacent)):
            if len(adjacent[i])==1:
                leaves.append(i) # find all the leaves, i.e. the node which is only connected by another node, degree=1.
        while n>2:
            n-=len(leaves)
            newleaves=[]
            for i in leaves:
                j=adjacent[i].pop()
                adjacent[j].remove(i)
                if len(adjacent[j])==1:
                    newleaves.append(j)
            leaves=newleaves
        return leaves