Leetcode 双周赛 33

直接模拟 没啥问题

class Solution:
    def thousandSeparator(self, n: int) -> str:
        if not n:
            return '0'
        ans=''
        i=0
        while n :
            ans=str(n%10)+ans
            i+=1
            if i%3==0:
                ans='.'+ans
            n//=10
        return ans if ans[0]!='.' else ans[1:]

拓扑排序 所求的点集就是入度为0的点集

class Solution:
    def findSmallestSetOfVertices(self, n: int, edges: List[List[int]]) -> List[int]:
        glyph=collections.defaultdict(set)
        cnt=[0 for _ in range(n)]
        for a,b in edges:
            cnt[b]+=1
            glyph[a].add(b)
        
        res=[i for i in range(n) if cnt[i]==0]
        return res

注意到乘二是全体乘，加一只能给一个元素加
那么所求最少就是（每个元素加一操作之和）+（全体元素中乘二次数最多的）
变为如何通过操作得到n
由于$n\ge 2$时，$n/2\ge 1$，所以求操作数时应先除以二而不是减去1

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans1=0
        ans2=0
        memo={}
        def getcnt(ni):
            ans1=0
            ans2=0
            while ni:
                if ni&1:
                    ni-=1
                    ans1+=1
                else:
                    ni//=2
                    ans2+=1
            return ans1,ans2
        
        for ni in nums:
            cnt1,cnt2=getcnt(ni)
            ans1+=cnt1
            ans2=max(ans2,cnt2)
        
        return ans1+ans2

广搜即可 注释见代码

class Solution:
    def containsCycle(self, grid: List[List[str]]) -> bool:
        m = len(grid)
        n = len(grid[0])
        used = [[0]*n for _ in range(m)]
        for i in range(m):
            for j in range(n):
                if used[i][j] == 0:
                    alpha = grid[i][j] 
                    cur = None
                    nxt = {(i, j)}
                    '''
                    当前正在搜索的目标字符
                    当前正在搜索的集合
                    下一步要搜索的集合
                    '''
                    while nxt:
                        cur = nxt
                        nxt = set()
                        for node in cur:
                            row, col = node
                            used[row][col] = 1
                            if row+1 < m and grid[row+1][col] == alpha and used[row+1][col] == 0:
                                neighbor = (row+1, col)
                                if neighbor in cur or neighbor in nxt:
                                    return True
                                else:
                                    nxt.add(neighbor)
                            if row-1 >= 0 and grid[row-1][col] == alpha and used[row-1][col] == 0:
                                neighbor = (row-1, col)
                                if neighbor in cur or neighbor in nxt:
                                    return True
                                else:
                                    nxt.add(neighbor)
                            if col+1 < n and grid[row][col+1] == alpha and used[row][col+1] == 0:
                                neighbor = (row, col+1)
                                if neighbor in cur or neighbor in nxt:
                                    return True
                                else:
                                    nxt.add(neighbor)
                            if col-1 >= 0 and grid[row][col-1] == alpha and used[row][col-1] == 0:
                                neighbor = (row, col-1)
                                if neighbor in cur or neighbor in nxt:
                                    return True
                                else:
                                    nxt.add(neighbor)
        return False

标号为搜索顺序