[Leetcode Weekly Contest]179

链接：LeetCode

[Leetcode]5352. 生成每种字符都是奇数个的字符串

给你一个整数 n，请你返回一个含 n 个字符的字符串，其中每种字符在该字符串中都恰好出现 奇数次 。返回的字符串必须只含小写英文字母。如果存在多个满足题目要求的字符串，则返回其中任意一个即可。

示例 1：
输入：n = 4
输出："pppz"
解释："pppz" 是一个满足题目要求的字符串，因为 'p' 出现 3 次，且 'z' 出现 1 次。当然，还有很多其他字符串也满足题目要求，比如："ohhh" 和 "love"。

由于只要返回任意一个能满足条件的字符串即可，那只需要分两种情况考虑，若n为奇数，直接返回n个‘a’，否则返回n-1个'a'和1个'b'即可。
另外，使用位运算'n&1==1'来判断奇偶性是最快的。

class Solution:
    def generateTheString(self, n: int) -> str:
        if n&1:
            return 'a'*n
        else:
            return 'a'*(n-1)+'b'

[Leetcode]5353. 灯泡开关 III

房间中有\(n\)枚灯泡，编号从 1 到 n，自左向右排成一排。最初，所有的灯都是关着的。
在\(k\) 时刻（\(k\)的取值范围是 0 到 n - 1），我们打开\(light[k]\)这个灯。
灯的颜色要想 变成蓝色 就必须同时满足下面两个条件：

• 灯处于打开状态。
• 排在它之前（左侧）的所有灯也都处于打开状态。

请返回能够让 所有开着的 灯都 变成蓝色 的时刻 数目 。

示例 1：
输入：\(light = [2,1,3,5,4]\)
输出：3
解释：所有开着的灯都变蓝的时刻分别是 1，2 和 4 。

示例 2：
输入：\(light = [3,2,4,1,5]\)
输出：2
解释：所有开着的灯都变蓝的时刻分别是 3 和 4（index-0）。

只需要考虑这样一个问题：由于灯泡的编号是1 到 n，假设第i个位置时，所有的灯泡都是蓝色的，那么它必须满足什么条件呢？假如从0到第i个位置的灯泡都蓝色，且从0到第i个位置的最大编号为\(k\)，则在i位置之前，必须存在1到\(k\)的编号，这样才能满足排在它之前（左侧）的所有灯也都处于打开状态。为了满足这个条件，在循环遍历数组的同时，更新遍历的最大值，再与索引判断即可。

class Solution:
    def numTimesAllBlue(self, light: List[int]) -> int:
        if not light:
            return 0
        max_num = 0
        res = 0
        for i,lig in enumerate(light):
            max_num = max(max_num,lig)
            if max_num == i+1:
                res += 1
        return res

[Leetcode]5354. 通知所有员工所需的时间

公司里有 n 名员工，每个员工的 ID 都是独一无二的，编号从 0 到 n - 1。公司的总负责人通过 headID 进行标识。
在 manager 数组中，每个员工都有一个直属负责人，其中 manager[i] 是第 i 名员工的直属负责人。对于总负责人，\(manager[headID] = -1\)。题目保证从属关系可以用树结构显示。
公司总负责人想要向公司所有员工通告一条紧急消息。他将会首先通知他的直属下属们，然后由这些下属通知他们的下属，直到所有的员工都得知这条紧急消息。
第 i 名员工需要\(informTime[i]\)分钟来通知它的所有直属下属（也就是说在\(informTime[i]\)分钟后，他的所有直属下属都可以开始传播这一消息）。
返回通知所有员工这一紧急消息所需要的 分钟数 。

示例 1：
输入：\(n = 1, headID = 0, manager = [-1], informTime = [0]\)
输出：0
解释：公司总负责人是该公司的唯一一名员工。

示例 2：
输入：\(n = 6, headID = 2, manager = [2,2,-1,2,2,2], informTime = [0,0,1,0,0,0]\)
输出：1
解释：id = 2 的员工是公司的总负责人，也是其他所有员工的直属负责人，他需要 1 分钟来通知所有员工。

一个类似寻找叶子节点最大累加值的问题，可以用图遍历的方法解决。图遍历的话一般采用BFS或者DFS的方法。这里DFS可以采用自顶向下方法和自底向上两种方案。这里我使用自底向上来进行图遍历。

import collections
class Solution:
    # BFS
    def numOfMinutes(self, n: int, headID: int, manager: List[int], informTime: List[int]) -> int:
        dic=collections.defaultdict(list)
        for i,manage in enumerate(manager):
            dic[manage].append([i,informTime[i]])
        queue = collections.deque()
        queue.append([headID,informTime[headID]])
        res = 0
        while queue:
            headID,path = queue.popleft()
            if headID not in dic:
                res  = max(res,path)
            for head,inform in dic[headID]:
                queue.append([head,path+inform])
        return res

    
    # DFS
    def numOfMinutes(self, n: int, headID: int, manager: List[int], informTime: List[int]) -> int:
        res = [0] * n
        for i in range(n):
            cur_i, result = i, 0
            while manager[cur_i] != -1:
                cur_i = manager[cur_i]
                result += informTime[cur_i]
            res[i] = result + res[cur_i]
            manager[i] = -1
        return max(res)

[Leetcode]5355. T 秒后青蛙的位置

给你一棵由 n 个顶点组成的无向树，顶点编号从 1 到 n。青蛙从 顶点 1 开始起跳。规则如下：
在一秒内，青蛙从它所在的当前顶点跳到另一个 未访问 过的顶点（如果它们直接相连）。
青蛙无法跳回已经访问过的顶点。
如果青蛙可以跳到多个不同顶点，那么它跳到其中任意一个顶点上的机率都相同。
如果青蛙不能跳到任何未访问过的顶点上，那么它每次跳跃都会停留在原地。
无向树的边用数组edges描述，其中\(edges[i] = [fromi, toi]\)意味着存在一条直接连通 fromi 和 toi 两个顶点的边。

示例 1：

输入：\(n = 7, edges = [[1,2],[1,3],[1,7],[2,4],[2,6],[3,5]], t = 2, target = 4\)
输出：0.16666666666666666
解释：上图显示了青蛙的跳跃路径。青蛙从顶点 1 起跳，第 1 秒 有 1/3 的概率跳到顶点 2 ，然后第 2 秒 有 1/2 的概率跳到顶点 4，因此青蛙在 2 秒后位于顶点 4 的概率是 1/3 * 1/2 = 1/6 = 0.16666666666666666 。

示例 2：

输入：\(n = 7, edges = [[1,2],[1,3],[1,7],[2,4],[2,6],[3,5]], t = 1, target = 7\)
输出：0.3333333333333333
解释：上图显示了青蛙的跳跃路径。青蛙从顶点 1 起跳，有 1/3 = 0.3333333333333333 的概率能够 1 秒 后跳到顶点 7 。

又是一道图搜索的问题，这里采用了朴素BFS搜素，中间需要注意已经访问过的点不能计算到概率当中。通过一个队列存储三个值：遍历到的点，该点到起始点1的时间，以及到该点的可能性。注意以下情况：
一、在\(time(time<t）\)时间到了target，如果其还有后续步骤，就返回0，因为青蛙会继续往下跳。 如果没有后续步骤，就返回当前的概率
二、在\(time(time>t)\)到达target，也返回0。

import collections
class Solution:
    def frogPosition(self, n: int, edges: List[List[int]], t: int, target: int) -> float:
        dic = collections.defaultdict(list)
        visit = set()
        for fromi,toi in edges:
            dic[fromi].append(toi)
            dic[toi].append(fromi)
             
        queue = collections.deque()
        queue.append([1,0,1])
        while queue:
            q,time,weight = queue.popleft()
            visit.add(q)
            num = len([x for x in dic[q] if x not in visit])
            if q==target:
                if time>t or (time<t and num):return 0
                else:return 1/weight
            for head in dic[q]:
                if head not in visit:
                    queue.append([head,time+1,weight*num])
        return 0