python leetcode 431-440

# 433
class Solution:
    def minMutation(self, start: str, end: str, bank: List[str]) -> int:
        bank = set(bank)
        if end not in bank:
            return -1
        change_map = {
            "A": "CGT",
            "C": "AGT",
            "G": "CAT",
            "T": "CGA",
        }
        min_count = len(bank) + 1
        def dfs(current, count, current_bank):
            nonlocal min_count
            # terminator
            if count > min_count:
                return
            if current == end:
                if count < min_count:
                    min_count = count
                return
            if not current_bank:
                return
            # process
            for i, s in enumerate(current):
                for char in change_map[s]:
                    new = current[:i] + char + current[i + 1:]
                    if new not in current_bank:
                        continue
                    current_bank.remove(new)
                    # drill down
                    dfs(new, count + 1, current_bank)

                    # reverse state
                    current_bank.add(new)
        dfs(start, 0, bank)
        return min_count if min_count <= len(bank) else -1

# 434
class Solution:
    def countSegments(self, s: str) -> int:
        return len(s.split())

# 435 
class Solution:
    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
        intervals.sort(key = lambda x : x[1])
        cur_end , num = float('-inf') , 0
        for start , end in intervals:
            if start >= cur_end:
                num += 1
                cur_end = end
        return len(intervals) - num

# 436
class Solution:
    def findRightInterval(self, intervals: List[List[int]]) -> List[int]:
        n = len(intervals)
        starts, ends = list(zip(*intervals))
        starts = sorted(zip(starts, range(n)))
        ends = sorted(zip(ends, range(n)))

        ans, j = [-1] * n, 0
        for end, id in ends:
            while j < n and starts[j][0] < end:
                j += 1
            if j < n:
                ans[id] = starts[j][1]
        return ans

# 437
class Solution:
    def pathSum(self, root: TreeNode, targetSum: int) -> int:
        def rootSum(root, targetSum):
            if root is None:
                return 0

            ret = 0
            if root.val == targetSum:
                ret += 1

            ret += rootSum(root.left, targetSum - root.val)
            ret += rootSum(root.right, targetSum - root.val)
            return ret
        
        if root is None:
            return 0
            
        ret = rootSum(root, targetSum)
        ret += self.pathSum(root.left, targetSum)
        ret += self.pathSum(root.right, targetSum)
        return ret

# 438
class Solution:
    def findAnagrams(self, s: str, p: str) -> List[int]:
        S = [0] * 26
        P = [0] * 26
        ans = []

        if len(s) < len(p):
            return ans
        for i in range(len(p)):
            P[ord(p[i]) - 97] += 1
            S[ord(s[i]) - 97] += 1
        if S == P:
            ans.append(0)
        for i in range(len(s) - len(p)):
            S[ord(s[i + len(p)]) - 97] += 1
            S[ord(s[i]) - 97] -= 1

            if S == P:
                ans.append(i + 1)

        return ans

0 0 突然想回来更新了 别问为什么 但是会员没有了 也不想做困难题 只做免费的简单中等题