[Leetcode/python] 第33场双周赛

千位分隔数

给你一个整数 n，请你每隔三位添加点（即 “.” 符号）作为千位分隔符，并将结果以字符串格式返回。’

解： 打卡题。 WA了三次- -

1. 点好写成了逗号
2. 数位不对
3. 前导零处理

class Solution:
    def thousandSeparator(self, n: int) -> str:
        ret = ""
        def f(x):
            if len(x) < 3:
                return "0"*(3-len(x)) + x
            else:
                return x
        while n:
            p = n // 1000
            if ret == "":
                if p:
                    ret = ret + f(str(n % 1000))
                else:    
                    ret = ret + str(n % 1000)
                    
            elif p:    
                ret = f(str(n%1000)) + "." + ret
            else:    
                ret = str(n%1000) + "." + ret
            n = n // 1000   
        return ret if ret != "" else "0"    

解二： 直接转字符串处理， 不但简单，而且没什么犯错的空间。

class Solution:
    def thousandSeparator(self, n: int) -> str:
        ret = ""
        s = str(n)
        for i,x in enumerate(s[::-1]):
            if i != 0 and i % 3 == 0:
                ret += "."
            ret += x    
        return ret[::-1]   

可以到达所有点的最少点数目

给你一个 有向无环图 ， n 个节点编号为 0 到 n-1 ，以及一个边数组 edges ，其中 edges[i] = [fromi,
toi] 表示一条从点 fromi 到点 toi 的有向边。

找到最小的点集使得从这些点出发能到达图中所有点。题目保证解存在且唯一。

你可以以任意顺序返回这些节点编号。

解：题目保证唯一解。 答案就是入度为0的点。 因为不能有环。

class Solution:
    def findSmallestSetOfVertices(self, n: int, edges: List[List[int]]) -> List[int]:
        deg = [0] * n
        for f, s in edges:
            deg[s] += 1
        return [ x for x in range(n) if deg[x] == 0]
            

得到目标数组的最少函数调用次数

给你一个与 nums 大小相同且初始值全为 0 的数组 arr ，请你调用以上函数得到整数数组 nums 。

请你返回将 arr 变成 nums 的最少函数调用次数。

答案保证在 32 位有符号整数以内。

解： 将整数进行2的幂次分解。

1. Code 1

import math
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        k = int(math.log(max(nums), 2))
        def f(n):
            ret = []
            while n:
                k = int(math.log(n, 2))
                ret.append(k)
                n -= 1 << k
            return len(ret)    
                
            
        ret = k
        for x in nums:
            if x == 0: continue
            ret += f(x)    
        return ret  

2. Code 2

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        import math
        ret = int(math.log(max(nums), 2))
        def f(x):
            return 0 if x == 0 else sum(1 for i in range(30) if x & (1 << i))
        for x in nums: ret += f(x)
        return ret    

二维网格图中探测环

给你一个二维字符网格数组 grid ，大小为 m x n ，你需要检查 grid 中是否存在 相同值 形成的环。

一个环是一条开始和结束于同一个格子的长度 大于等于 4
的路径。对于一个给定的格子，你可以移动到它上、下、左、右四个方向相邻的格子之一，可以移动的前提是这两个格子有 相同的值 。

同时，你也不能回到上一次移动时所在的格子。比方说，环 (1, 1) -> (1, 2) -> (1, 1) 是不合法的，因为从 (1,
2) 移动到 (1, 1) 回到了上一次移动时的格子。

如果 grid 中有相同值形成的环，请你返回 true ，否则返回 false

解： BFS搜索。

1. 不能写递归， 会爆栈。
2. 将上一步的坐标保留下来。 因为最小环可以是4。只要不是回到上一步， 且访问过值相同的点， 就找到了答案。

class Solution:
    def containsCycle(self, grid: List[List[str]]) -> bool:
        n, m = len(grid), len(grid[0])
        def idx(i,j): return i*m + j
        def valid(i, j): return 0 <= i < n and 0 <= j < m
        vis = set()
        def solve(x, y, path):
            Q = [[x, y, -1, -1]]
            while Q:
                i, j, pi, pj = Q[0]
                del Q[0]
                for dx, dy in [[0,1], [0,-1], [1, 0], [-1, 0]]:
                    ni, nj = i + dx, j + dy
                    if valid(ni, nj) and grid[ni][nj] == grid[i][j] and (ni, nj) != (pi, pj):
                        if idx(ni, nj) in path:
                            return True
                        else:
                            Q.append([ni, nj, i, j])
                            vis.add(idx(ni, nj))
                            path.add(idx(ni, nj))
            return False                  
                
        for i in range(n):
            for j in range(m):
                if idx(i,j) not in vis:
                    vis.add(idx(i,j))
                    if solve(i, j, {idx(i,j)}):
                        return True
        return False