[Leetcode Weekly Contest]182

链接：LeetCode

[Leetcode]1394. 找出数组中的幸运数

在整数数组中，如果一个整数的出现频次和它的数值大小相等，我们就称这个整数为「幸运数」。
给你一个整数数组 arr，请你从中找出并返回一个幸运数。

• 如果数组中存在多个幸运数，只需返回 最大 的那个。
• 如果数组中不含幸运数，则返回 -1 。

字典不解释。

import collections
class Solution:
    def findLucky(self, arr: List[int]) -> int:
        count = collections.Counter(arr)
        res = -1
        for key in set(arr):
            if key == count[key]:
                res = max(res,key)
        return res

[Leetcode]1395. 统计作战单位数

每 3 个士兵可以组成一个作战单位，分组规则如下：
从队伍中选出下标分别为 i、j、k 的 3 名士兵，他们的评分分别为 (rating[i])、(rating[j])、(rating[k])
作战单位需满足：(rating[i] < rating[j] < rating[k])或者(rating[i] > rating[j] > rating[k])，其中$ 0 <= i < j < k < n$
请你返回按上述条件可以组建的作战单位数量。每个士兵都可以是多个作战单位的一部分。

一个通用的想法是，是以某个位置作为固定数，比较两侧满足升序或者降序的士兵的个数，相乘相加即可。在寻找两侧比其大/小的数，可以采用遍历或者线段树的方法。

class Solution:
    def numTeams(self, rating: List[int]) -> int:
        return self.getNum(rating)+self.getNum(rating[::-1])

    # 左小右大
    def getNum(self,nums):
        left = [0 for i in range(len(nums))]
        right = [0 for i in range(len(nums))]
        for i in range(len(nums)):
            for j in range(i):
                if nums[j] < nums[i]:
                    left[i] += 1
            for j in range(i+1,len(nums)):
                if nums[j] > nums[i]:
                    right[i] += 1
        res = 0
        for i in range(len(nums)):
            res += left[i] * right[i]
        return res

[Leetcode]1396. 设计地铁系统

请你实现一个类 UndergroundSystem ，它支持以下 3 种方法：
1. checkIn(int id, string stationName, int t)
编号为 id 的乘客在 t 时刻进入地铁站 stationName 。
一个乘客在同一时间只能在一个地铁站进入或者离开。
2. checkOut(int id, string stationName, int t)
编号为 id 的乘客在 t 时刻离开地铁站 stationName 。
3. getAverageTime(string startStation, string endStation)

• 返回从地铁站 startStation 到地铁站 endStation 的平均花费时间。
• 平均时间计算的行程包括当前为止所有从 startStation 直接到达 endStation 的行程。
• 调用 getAverageTime 时，询问的路线至少包含一趟行程。

你可以假设所有对 checkIn 和 checkOut 的调用都是符合逻辑的。也就是说，如果一个顾客在 t1 时刻到达某个地铁站，那么他离开的时间 t2 一定满足 t2 > t1 。所有的事件都按时间顺序给出。

使用字典保存信息，在查询平均时间时，只需要查询两个车站，得到总时间，和总次数

class UndergroundSystem:
    def __init__(self):
        self.ids = {}
        self.underground = {}

    def checkIn(self, id: int, stationName: str, t: int) -> None:
        self.ids[id] = [stationName,t]

    def checkOut(self, id: int, stationName: str, t: int) -> None:
        start_stationName,start_time = self.ids[id]
        check_stationName = start_stationName+stationName
        pay_time = t-start_time
        if check_stationName not in self.underground:
            self.underground[check_stationName] = [1,pay_time]
        else:
            self.underground[check_stationName][0] += 1
            self.underground[check_stationName][1] += pay_time


    def getAverageTime(self, startStation: str, endStation: str) -> float:
        times,time = self.underground[startStation+endStation]
        return time/times



# Your UndergroundSystem object will be instantiated and called as such:
# obj = UndergroundSystem()
# obj.checkIn(id,stationName,t)
# obj.checkOut(id,stationName,t)
# param_3 = obj.getAverageTime(startStation,endStation)

[Leetcode]1397. 找到所有好字符串

给你两个长度为 n 的字符串 s1 和 s2 ，以及一个字符串 evil 。请你返回 好字符串 的数目。
好字符串 的定义为：它的长度为 n ，字典序大于等于 s1 ，字典序小于等于 s2 ，且不包含 evil 为子字符串。
由于答案可能很大，请你返回答案对(10^9 + 7)取余的结果。
示例 1：
输入：n = 2, s1 = "aa", s2 = "da", evil = "b"
输出：51
解释：总共有 25 个以 'a' 开头的好字符串："aa"，"ac"，"ad"，...，"az"。还有 25 个以 'c' 开头的好字符串："ca"，"cc"，"cd"，...，"cz"。最后，还有一个以 'd' 开头的好字符串："da"。
示例 2：
输入：n = 8, s1 = "leetcode", s2 = "leetgoes", evil = "leet"
输出：0
解释：所有字典序大于等于 s1 且小于等于 s2 的字符串都以 evil 字符串 "leet" 开头。所以没有好字符串。
示例 3：
输入：n = 2, s1 = "gx", s2 = "gz", evil = "x"
输出：2

这道题是本周的压轴题，也是我第一次接触这种题型，收获很大，采用的是数位 DP + KMP的方法。数位DP 问题往往都是这样的题型，给定一个闭区间([l, r])，让你求这个区间中满足某种条件的数的总数。数位DP实际上是DFS+记忆化搜索，关于数位DP的基础知识可以参考数位DP。
这道题的最大难点在于，我们要求计算有多少个字符串“不包含”某个子串，通过KMP算法是便于我们找出当前字符串与模式串的最大匹配位数，当出现下一位不匹配时，我们可以直接找出下一个需要匹配的字符位置，这里也就是next数组的作用了。

class Solution:
    def findGoodStrings(self, n: int, s1: str, s2: str, evil: str) -> int:
        MOD = 1000000007
        if s1 > s2:
            return 0
        self.next_ = self.getNext(evil)
        self.dp = [[-1 for j in range(len(evil))] for i in range(n)]
        ans = self.dfs(s2,evil,0, 0, True) % MOD - self.dfs(s1,evil,0, 0, True) % MOD + MOD
        if evil not in s1:
            ans += 1
        return ans % MOD

    def getNext(self, p):
        p += '*'
        len_p = len(p)
        next = [-1 for i in range(len_p)]
        j,k = 0,-1
        while j<len_p-1:
            if p[j] == p[k] or k==-1:
                j+=1
                k+=1
                next[j] = k
            else:
                k = next[k]
        return next

    def dfs(self,s,evil,x,match,flag):
        n,m = len(s),len(evil)
        if match >= m:
            return 0
        if x >= n:
            return 1
        if not flag and  self.dp[x][match] != -1:
            return self.dp[x][match];
        lim = s[x] if flag else 'z'
        ret = 0
        for k in range(ord('a'),ord(lim)+1):
            cur = chr(k)
            nxt = match;
            while nxt > 0 and evil[nxt] != cur:
                  nxt = self.next_[nxt]
            if cur == evil[nxt]: nxt += 1
            ret += self.dfs(s,evil,x + 1, nxt, flag and (cur == lim))

        if not flag: self.dp[x][match] = ret
        return ret

参考：
leetcode