leetcode_185_contest

5388. 重新格式化字符串

思路：
统计字母个数n1和数字个数n2， 如果abs(n1-n2) > 1，不存在满足要求的字符串，返回空串。否则，相邻间隔一次插入就行。

class Solution:
    def reformat(self, s: str) -> str:
        res = ""
        ch=""
        num=""
        for x in s:
            if x>='a' and x<='z':
                ch += x
            else:
                num += x
        if abs(len(ch)-len(num)) >= 2 :
            return ""
        else:
            i=0
            
            while i<min(len(ch),len(num)) :
                if len(ch)>len(num) :
                    res += ch[i]+num[i]
                else:
                    res += num[i]+ch[i]
                i+=1
            if i>=len(ch) and i<len(num) :
                res += num[i]
            elif i>=len(num) and i<len(ch) :
                res += ch[i]
        return res

5389. 点菜展示表

思路：
以(tableNumberi, foodItemi)为键，利用哈希表（python中的字典）存储对应的数据；

from collections import Counter
class Solution:
    def displayTable(self, orders: List[List[str]]) -> List[List[str]]:
        food_set = set()
        table_set = set()
        table_food_dict = Counter()
        res = []
        for order in orders:
            _,table,food = order
            table = int(table)
            table_food_dict[(table, food)] += 1
            food_set.add(food)
            table_set.add(table)
        food_set= sorted(list(food_set))
        table_set= sorted(list(table_set))
        res.append(['Table']+food_set)
        for table in table_set:
            line = []
            line.append(str(table))
            for food in food_set:
                line.append(str(table_food_dict[(table,food)]))
            res.append(line)
        return res

5390. 数青蛙

思路：
利用数组记录每个字符的个数， 根据当前字符i计算需要的前一个字符i-1，前一个字符串个数减1，当前字符串个数加1。因为'c'是起始字符，前一个字符为'k'，特殊判断当前是否有字符为k，没有的话需要增加一只青蛙。查找过程中如果有字符个数小于0，直接返回。最后判断‘c’, ’r’, ’o’, ’a’ 四个字符的个数。

from collections import defaultdict
import queue
class Solution:
    def minNumberOfFrogs(self, croakOfFrogs: str) -> int:
        map_ = {'c':0,'r':1,'o':2,'a':3,'k':4}
        num_list = [0] * 5
        res = 0
        for x in croakOfFrogs:
            num = map_[x]
            if num == 0:
                if num_list[4] <= 0:
                    res += 1
                    num_list[num] += 1
                else :
                    num_list[4] -= 1
                    num_list[0] += 1
            else:
                t = (num + 4) % 5
                num_list[t] -= 1
                num_list[num] += 1
            for i in range(5):
                if num_list[i] < 0:
                    return -1
        for i in range(4):
            if num_list[i] < 0:
                    return -1
        return res

5391. 生成数组

思路：
动态规划求解：设 dp[i][j][l] 为长度为 i，最大值为 j，search_cost 为 l 的数组的数目，则 $ \sum_{j=1}^{m}dp[n][j][k]$ 即为所求.
边界条件 dp[0][j][l] = dp[i][0][l] = dp[i][j][0] = 0，dp[1][j][1] = 1，而对于其它的 i, j, l 分两种情况考虑：

1. 当最大值 j 恰好只出现在数组末尾时，构造的方法有 $\sum_{t=1}^{j-1}dp[i-1][t][l-1] $种，即前 i-1 个元素都小于 j；
2. 而当最大值出现在前 i-1个元素之中时，数组末尾的元素可以从 1 到 j 中任意选取，即有 $ j \times dp[i-1][j][l]$种构造方法。
   综上所述，有 $$dp[i][j][l] = j \times dp[i-1][j][l] + \sum_{t=1}^{j-1}dp[i-1][t][l-1]$$

class Solution {
public:
    int numOfArrays(int n, int m, int k) {
        const int MOD = 1e9+7;
        long long dp[55][110][55];
        memset(dp,0,sizeof dp);

        for(int i=1;i<=m;++i) dp[1][i][1] = 1;
        
        for(int i=1;i<=n;++i){
            for(int j=1;j<=m;++j){
                for(int l=1;l<=k;++l){
                    if(i==1 && l==1)continue;
                    for(int t=1;t<j;++t){
                        dp[i][j][l] += dp[i-1][t][l-1];
                        dp[i][j][l] %= MOD;
                    }
                    dp[i][j][l] += j*dp[i-1][j][l];
                    dp[i][j][l] %= MOD;
                }
            }
        }
        long long res = 0;
        for(int i=0;i<=m;++i){
            res += dp[n][i][k];
            res %= MOD;
        }
        return int(res);
    }
};