[Leetcode Weekly Contest]185

链接：LeetCode

[Leetcode]1417. 重新格式化字符串

给你一个混合了数字和字母的字符串 s，其中的字母均为小写英文字母。
请你将该字符串重新格式化，使得任意两个相邻字符的类型都不同。也就是说，字母后面应该跟着数字，而数字后面应该跟着字母。
请你返回 重新格式化后 的字符串；如果无法按要求重新格式化，则返回一个 空字符串 。

直接暴力就可以了。

class Solution:
    def reformat(self, s: str) -> str:
        s1 = [ch for ch in s if ch.isdigit()]
        s2 = [ch for ch in s if ch.isalpha()]
        res = ''
        if abs(len(s1)-len(s2)) > 1:
            return res
        if len(s1) > len(s2):
            res += s1[0] + ''.join([''.join(x) for x in list(zip(s2,s1[1:]))])
        elif len(s1) < len(s2):
            res += s2[0]+ ''.join([''.join(x) for x in list(zip(s1,s2[1:]))])
        else:
            res += ''.join([''.join(x) for x in list(zip(s1,s2))])
        return res

[Leetcode]1418. 点菜展示表

给你一个数组 orders，表示客户在餐厅中完成的订单，确切地说， \(orders[i]=[customerNamei,tableNumberi,foodItemi]\)，其中 customerNamei 是客户的姓名，tableNumberi 是客户所在餐桌的桌号，而 foodItemi 是客户点的餐品名称。
请你返回该餐厅的 点菜展示表 。在这张表中，表中第一行为标题，其第一列为餐桌桌号 “Table” ，后面每一列都是按字母顺序排列的餐品名称。接下来每一行中的项则表示每张餐桌订购的相应餐品数量，第一列应当填对应的桌号，后面依次填写下单的餐品数量。
注意：客户姓名不是点菜展示表的一部分。此外，表中的数据行应该按餐桌桌号升序排列。

直接暴力就可以了。

class Solution:
    def displayTable(self, orders):
        tableNumbers = set()
        foodItems = set()
        items = {}
        for name,tableNumber,foodItem in orders:
            tableNumbers.add(tableNumber)
            foodItems.add(foodItem)
            if tableNumber not in items:
                items[tableNumber] = collections.defaultdict(int)
            items[tableNumber][foodItem] += 1
        res = [['' for _ in range(len(foodItems)+1)] for _ in range(len(tableNumbers)+1)]
        foodItems = sorted(list(foodItems))
        res[0] = ['Table'] + foodItems
        tableNumbers = sorted(list(tableNumbers),key=lambda x:int(x))
        for i in range(len(tableNumbers)):
            res[i+1][0] = str(tableNumbers[i])
            for j in range(len(foodItems)):
                res[i+1][j+1] = str(items[tableNumbers[i]][foodItems[j]])
        return res

[Leetcode]5390. 数青蛙

给你一个字符串 croakOfFrogs，它表示不同青蛙发出的蛙鸣声（字符串 "croak" ）的组合。由于同一时间可以有多只青蛙呱呱作响，所以 croakOfFrogs 中会混合多个 “croak” 。请你返回模拟字符串中所有蛙鸣所需不同青蛙的最少数目。
注意：要想发出蛙鸣 "croak"，青蛙必须 依序 输出 ‘c’, ’r’, ’o’, ’a’, ’k’ 这 5 个字母。如果没有输出全部五个字母，那么它就不会发出声音。
如果字符串 croakOfFrogs 不是由若干有效的 "croak" 字符混合而成，请返回 -1 。

遍历字符串，要求现存的字符串中字符串数量 c >= r >= o >= a >= k，否则返回 -1。青蛙的数量即，遍历过程中，最大的，出现c的个数比k更多的数量。

class Solution:
    def minNumberOfFrogs(self, croakOfFrogs: str) -> int:
        if not croakOfFrogs.count('c') == croakOfFrogs.count('r') == croakOfFrogs.count('o') == croakOfFrogs.count('a') == croakOfFrogs.count('k'):
            return -1
        nums = [0 for i in range(5)]
        flag = [True] + [False for i in range(4)]
        dic = {ch:i for i,ch in enumerate('croak')}
        res = result = 0
        for ch in croakOfFrogs:
            i = dic[ch]
            if not flag[i]:
                return -1
            nums[i] += 1
            if i<4:
                flag[i+1] = True
            if i>0 and nums[i]==nums[i-1]:
                flag[i] = False
            if ch == 'c':
                result += 1
            if ch== 'k':
                result -= 1
            res = max(result,res)
        return res

[Leetcode]1420. 生成数组

给你三个整数 n、m 和 k 。下图描述的算法用于找出正整数数组中最大的元素。

请你生成一个具有下述属性的数组 arr ：

• arr 中有\(n\)个整数。
• \(1 <= arr[i] <= m 其中 (0 <= i < n) 。\)
• 将上面提到的算法应用于 arr ，search_cost 的值等于 k 。
  返回上述条件下生成数组 arr 的 方法数 ，由于答案可能会很大，所以 必须 对 10^9 + 7 取余。

示例 1：
输入：n = 2, m = 3, k = 1
输出：6
解释：可能的数组分别为\([1, 1], [2, 1], [2, 2], [3, 1], [3, 2] [3, 3]\)

动态规划，啥也不说了，看参考吧。

class Solution:
    def numOfArrays(self, n: int, m: int, k: int) -> int:
        if k == 0:
            return 0
        dp = [[[0] * (m) for _ in range(k + 1)] for __ in range(n)]
        dp[0][1] = [1] * m

        for i in range(1, n):
            for j in range(1, k + 1):
                for p in range(m):
                    dp[i][j][p] = sum(dp[i - 1][j - 1][: p]) + dp[i - 1][j][p] * (p + 1)
                    dp[i][j][p] %= 1e9+7

        return int(sum(dp[-1][-1])%(1e9+7))

参考：
leetcode