leetcode刷題記錄441-450 python版

前言

繼續leetcode刷題生涯
這裏記錄的都是筆者覺得有點意思的做法
參考了好幾位大佬的題解，尤其是powcai大佬和labuladong大佬，感謝各位大佬

441. 排列硬幣

class Solution:
    def arrangeCoins(self, n: int) -> int:
        i = 1
        while n - i >= 0:
            n -= i
            i += 1
        return i - 1
# 數學
class Solution:
    def arrangeCoins(self, n: int) -> int:  
        return int(((8 * n + 1) ** 0.5 - 1) // 2)

442. 數組中重複的數據

class Solution:
    def findDuplicates(self, nums: List[int]) -> List[int]:
        res = []
        for num in nums:
            loc = abs(num) - 1 #索引
            if nums[loc] < 0:
                res.append(loc + 1)
            nums[loc] = -nums[loc]
        return res

443. 壓縮字符串

# 讀寫指針
class Solution:
    def compress(self, chars: List[str]) -> int:
        i = 0
        j = 0
        while j < len(chars):
            chars[i] = chars[j]
            i += 1
            num = 1
            while j + 1 < len(chars) and chars[j + 1] == chars[j]:
                num += 1
                j += 1
            if num != 1:
                for s in str(num):
                    chars[i] = s
                    i += 1
            j += 1
        return i

445. 兩數相加 II

# 棧
class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        stack1 = []
        stack2 = []
        dummy = ListNode(-1)
        def push_stack(p, stack):
            while p:
                stack.append(p.val)
                p = p.next
        push_stack(l1, stack1)
        push_stack(l2, stack2)
        carry = 0
        while stack1 or stack2 or carry:
            tmp1, tmp2 = 0, 0
            if stack1: tmp1 = stack1.pop()
            if stack2: tmp2 = stack2.pop()
            carry, mod = divmod(tmp1 + tmp2 + carry, 10)
            # 頭插法
            new_node = ListNode(mod)
            new_node.next = dummy.next
            dummy.next = new_node
        return dummy.next

446. 等差數列劃分 II - 子序列

# dp
class Solution:
    def numberOfArithmeticSlices(self, A: List[int]) -> int:
        from collections import defaultdict
        dp = [defaultdict(int) for _ in range(len(A))]
        res = 0
        for i in range(len(A)):
            for j in range(i):
                diff = A[i] - A[j]
                dp[i][diff] += dp[j][diff] +  1
                # 說明滿足長度大於等於3
                if diff in dp[j]:
                    res += dp[j][diff]
        return res

447. 迴旋鏢的數量

class Solution:
    def numberOfBoomerangs(self, points: List[List[int]]) -> int:
        from collections import defaultdict
        n = len(points)
        res = 0
        def distance(i, j):
            return (points[i][0] - points[j][0]) ** 2 + (points[i][1] - points[j][1]) ** 2
        res = 0
        for i in range(n):
            # 統計在i點下與其他點的距離
            lookup = defaultdict(int)
            for j in range(n):
                if i != j:
                    lookup[distance(i, j)] += 1
            # 排列組合
            for d in lookup.values():
                res += d * (d - 1)
        return res

448. 找到所有數組中消失的數字

# 類似442重複數據
class Solution:
    def findDisappearedNumbers(self, nums: List[int]) -> List[int]:
        res = []
        for num in nums:
            loc = abs(num) - 1 #索引
            if nums[loc] > 0:
                nums[loc] = -nums[loc]
        for idx, val in enumerate(nums, 1):
            if val > 0:
                res.append(idx)
        return res

449. 序列化和反序列化二叉搜索樹

class Codec:
    def serialize(self, root):
        """Encodes a tree to a single string.
        :type root: TreeNode
        :rtype: str
        """
        res = []
        def preorder(root):
            if not root:
                res.append("#")
                return
            res.append(str(root.val))
            preorder(root.left)
            preorder(root.right)
        preorder(root)
        return ",".join(res)
    def deserialize(self, data):
        """Decodes your encoded data to tree.
        :type data: str
        :rtype: TreeNode
        """
        d = iter(data.split(","))
        def helper():
            tmp = next(d)
            if tmp == "#": return
            node = TreeNode(int(tmp))
            node.left = helper()
            node.right = helper()
            return node
        return helper()

450. 刪除二叉搜索樹中的節點

# 二叉搜索樹性質
class Solution:
    def deleteNode(self, root: TreeNode, key: int) -> TreeNode:
        def delete(root, key, l):
            if not root:
                return l
            if root.val == key:
                return delete(root.right, key, root.left)
            elif root.val < key:
                root.right = delete(root.right, key, l)
                return root
            else:
                root.left = delete(root.left, key, l)
                return root
        return delete(root, key, None)