lc marathon 7.7

313. 超级丑数

与264. 丑数 II同样的解题逻辑

要得到从小到大的第 n 个丑数，可以使用最小堆实现。

初始时堆为空。首先将最小的丑数 1 加入堆。

每次取出堆顶元素 x，则 x是堆中最小的丑数，由于 prime[0]*x, prime[1]*x, prime[2]*x… 也是丑数，因此将prime[0]*x, prime[1]*x, prime[2]*x…加入堆。

上述做法会导致堆中出现重复元素的情况。为了避免重复元素，可以使用哈希集合去重，避免相同元素多次加入堆。

在排除重复元素的情况下，第 nn 次从最小堆中取出的元素即为第 n 个丑数

class Solution:
    def nthSuperUglyNumber(self, n: int, primes: List[int]) -> int:
        s={1}
        ls=[1]
        heapq.heapify(ls)
        rs=-1
        for i in range(n):
            rs=heapq.heappop(ls)
            print(rs)
            for num in primes:
                if rs*num not in s:
                    #ls.append(rs*num)
                    heapq.heappush(ls,rs*num) # heappush 和 heappop 必须一起用才能达到最小堆的效果
                    s.add(rs*num)
        return rs

129. 求根节点到叶节点数字之和

和作为全局变量

当一个节点不具有左节点和右节点时，即为叶子节点

这时候向全局变量加保存的轨迹即可

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

sums=0
class Solution:
    def sumNumbers(self, root: TreeNode) -> int:
        global sums
        sums=0
        dfs(root,"")
        return sums
def dfs(root,ls):
    global sums
    if root==None:
        return 
    else:
        ls+=str(root.val)
    if root.left==None and root.right==None:
        sums+=int(ls)
            
    else:
        dfs(root.left,ls)
        dfs(root.right,ls)

284. 顶端迭代器

不要学我，我直接全存储到list里了，这样写着很爽

class PeekingIterator:
    def __init__(self, iterator):
        """
        Initialize your data structure here.
        :type iterator: Iterator
        """
        self.ls=[]
        while iterator.hasNext():
            self.ls.append(iterator.next())
        self.index=-1
    def peek(self):
        """
        Returns the next element in the iteration without advancing the iterator.
        :rtype: int
        """
        return self.ls[self.index+1]
    def next(self):
        """
        :rtype: int
        """
        self.index+=1
        return self.ls[self.index]
    def hasNext(self):
        """
        :rtype: bool
        """
        if self.index<len(self.ls)-1:
            return True
        else:
            return False