【Leetcode第213场周赛】score:13 Time: 1:01:47 Rank:261/3826

第二次参加周赛，第一次做完了所有题目（第三题理解错题意，在周赛结束4分钟后提交通过）

看题目吧

5554.能否连接形成数组（3分，通过率：2245/3599）

给你一个整数数组 arr ，数组中的每个整数 互不相同 。另有一个由整数数组构成的数组 pieces，其中的整数也 互不相同 。请你以 任意顺序 连接 pieces 中的数组以形成 arr 。但是，不允许 对每个数组 pieces[i] 中的整数重新排序。

如果可以连接 pieces 中的数组形成 arr ，返回 true ；否则，返回 false 。

本题在力扣中属于简单题，主要是因为题目中给的两个“互不相同”，可以避免了很多的讨论情况

class Solution:
    def canFormArray(self, arr: List[int], pieces: List[List[int]]) -> bool:
        for words in pieces:
            if len(words) != 1:
                if words[0] not in arr:
                    return False
                index_stand = arr.index(words[0])
                
                for i in range(1,len(words)):
                    if words[i] not in arr or arr.index(words[i])!= index_stand+1:
                        return False
                    else:
                        index_stand = arr.index(words[i])
            else:
                if words[0] not in arr:
                    return False
        return True

时间复杂度O(n)，空间复杂度O(1)

5555. 统计字典序元音字符串的数目（4分，通过率：1879/2350）
给你一个整数 n，请返回长度为 n 、仅由元音 (a, e, i, o, u) 组成且按 字典序排列 的字符串数量。
字符串 s 按 字典序排列 需要满足：对于所有有效的 i，s[i] 在字母表中的位置总是与 s[i+1] 相同或在 s[i+1] 之前。

这题挺简单的，感觉不算中等难度的题…

class Solution:
    def countVowelStrings(self, n: int) -> int:
        Lis = [1,1,1,1,1]
        n -= 1
        while(n):
            n -= 1
            for i in range(4,-1,-1):
                for j in range(0,i):
                    Lis[i] += Lis[j]
        return sum(Lis)

5556. 可以到达的最远建筑（5分，通过率：994/2721）
给你一个整数数组 heights ，表示建筑物的高度。另有一些砖块 bricks 和梯子 ladders 。

你从建筑物 0 开始旅程，不断向后面的建筑物移动，期间可能会用到砖块或梯子。

当从建筑物 i 移动到建筑物 i+1（下标 从 0 开始 ）时：

如果当前建筑物的高度 大于或等于 下一建筑物的高度，则不需要梯子或砖块
如果当前建筑的高度 小于 下一个建筑的高度，您可以使用 一架梯子 或 (h[i+1] - h[i]) 个砖块
如果以最佳方式使用给定的梯子和砖块，返回你可以到达的最远建筑物的下标（下标 从 0 开始 ）。

这道题我用的搜索回溯，也就是暴力法，但是由于少看了一句“下标从0开始”，导致我一直在debug。在周赛结束刚结束没几分钟，突然发现了这句话，然后改了下代码就过了

class Solution:
    def furthestBuilding(self, heights: List[int], bricks: int, ladders: int) -> int:
        self.bricks = bricks
        self.ladders = ladders
        self.max_ = 0

        len_ = len(heights)
        if len_ == 1:
            return 1
        for i in range(1,len_):
            heights[i-1] = 0 if heights[i-1]>heights[i] else heights[i] - heights[i-1]
        
        def dfs(index):
            if index == len_:
                return 
                
            if self.bricks >= heights[index]:
                self.bricks -= heights[index]
                self.max_ = max(self.max_,index+1)
                dfs(index+1)
                self.bricks += heights[index]
                
            if self.ladders >= 1:
                self.ladders -= 1
                self.max_ = max(self.max_,index+1)
                dfs(index+1)
                
            return self.max_ if self.max_<len_ else self.max_ - 1
        
        return dfs(0)

5556. 可以到达的最远建筑（6分，通过率：356/1314）
Bob 站在单元格 (0, 0) ，想要前往目的地 destination ：(row, column) 。他只能向 右 或向 下 走。你可以为 Bob 提供导航 指令 来帮助他到达目的地 destination 。

指令 用字符串表示，其中每个字符：

‘H’ ，意味着水平向右移动
‘V’ ，意味着竖直向下移动
能够为 Bob 导航到目的地 destination 的指令可以有多种，例如，如果目的地 destination 是 (2, 3)，“HHHVV” 和 “HVHVH” 都是有效 指令 。

然而，Bob 很挑剔。因为他的幸运数字是 k，他想要遵循 按字典序排列后的第 k 条最小指令 的导航前往目的地 destination 。k 的编号 从 1 开始 。

给你一个整数数组 destination 和一个整数 k ，请你返回可以为 Bob 提供前往目的地 destination 导航的 按字典序排列后的第 k 条最小指令 。

这道其实就是一个数学题，思路是：如果选择H，则字典序不会增加，选择V，则需计入所有以H开头的字符串数目，我们只需要计算以H开头的字符串数目，判断是否超过了K，根据这个判断，选择H or V

class Solution:
    def kthSmallestPath(self, destination: List[int], k: int) -> str:
        column,row = destination[1],destination[0]
        ans = ""
        def compose(a,b):
            return 1 if not a else math.factorial(b)//math.factorial(a)//math.factorial(b-a)

        while (row != 0):
            if not column:
                return ans + "V" * row
            standard = compose(row,row+column-1)
            if standard >= k:
                ans += "H"
                column -= 1
            else:
                ans += "V"
                row,k = row-1,k-standard      
        return ans + "H"*column