leetcode biweekly 61全AC解

比赛链接
思路：

1. 暴力
2. 递归+分情况讨论0
3. dp
4. 滑窗，脑筋急转弯

5859. Count Number of Pairs With Absolute Difference K

class Solution:
    def countKDifference(self, nums: List[int], k: int) -> int:
        ans=0
        for i in range(len(nums)-1):
            for j in range(i+1,len(nums)):
                if abs(nums[i]-nums[j])==k:
                    ans+=1
        return ans

5860. Find Original Array From Doubled Array

from collections import Counter
class Solution:
    def findOriginalArray(self, changed: List[int]) -> List[int]:
        #TODO count 0 separately
        if not len(changed) or len(changed)%2!=0 or sum(changed)%3!=0 or len([e for e in changed if e%2==0])*2<len(changed):
            return []
        zeros=len([e for e in changed if e==0])
        if zeros%2!=0:
            return []
        changed=[e for e in changed if e!=0]
        changed.sort()
        #take every odd
        freq=dict(Counter(changed))
        ans=[0 for _ in range(zeros//2)]
        for k,v in freq.items():
            if k%2==1:
                ans.extend([k for _ in range(v)])
                if k*2 not in freq or freq[k*2]<v:
                    return [] #not enough odd
                else:
                    freq[k*2]-=v
                    freq[k]=0
        #notice now the problem is reducable to arr / 2
        new_changed=[]
        for k,v in freq.items():
            new_changed.extend([k//2 for _ in range(v)])
        return ans+[e*2 for e in self.findOriginalArray(new_changed)]

5861. Maximum Earnings From Taxi

from collections import defaultdict
from functools import lru_cache
class Solution:
    def maxTaxiEarnings(self, n: int, rides: List[List[int]]) -> int:
        book=defaultdict(list)
        for s,e,t in rides:
            book[e].append((s,t))
            
        @lru_cache(None)
        def dp(end):
            if end==1:
                return 0
            ans=dp(end-1)
            if len(book[end]):
                for s,t in book[end]:
                    ans=max(ans,dp(s)+end-s+t)
            return ans
        
        for end in range(1,n+1):
            dp(end)
        return dp(n)

5862. Minimum Number of Operations to Make Array Continuous

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        diff=len(nums)-1
        fnums=list(set(nums))
        fnums.sort()
        l,r=0,0
        best_gap=0
        while l<len(fnums):
            while r<len(fnums) and fnums[r]-fnums[l]<=diff:
                r+=1
            best_gap=max(best_gap,r-l)
            l+=1
        return len(nums)-best_gap

（10点50分抱着玩玩的心态进去，居然都AC了哈哈哈）