LeetCode笔记：Weekly Contest 243 比赛记录

LeetCode笔记：Weekly Contest 243

LeetCode笔记：Weekly Contest 243

1. 题目一

给出题目一的试题链接如下：

1880. Check if Word Equals Summation of Two Words

1. 解题思路

这一题依然没啥好多说的，就是把字符变换为数字，然后求和比对一下即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def isSumEqual(self, firstWord: str, secondWord: str, targetWord: str) -> bool:
        def str2num(word):
            res = "".join(chr(ord('0') + ord(c)-ord('a')) for c in word)
            # print(res)
            return int(res)
        
        return str2num(firstWord) + str2num(secondWord) == str2num(targetWord)

提交代码评测得到：耗时32ms，占用内存14.5MB。

2. 题目二

给出题目二的试题链接如下：

1881. Maximum Value after Insertion

1. 解题思路

这题需要分类讨论一下，如果原数为正数，那么就要获得最大的插入，反之，如果原数为负数，那么就要进行最小的插入。

不过插入方式本身大同小异，最大插入就是插入到目标元素大于原数组中第一个比该元素小的元素位置上，反之最小插入只需要插入到第一个比目标元素大的元素位置上即可。

唯一需要注意一下的是，最小插入时当目标元素为0时，不能够插入到第一个元素当中。

2. 代码实现

给出python代码实现如下：

class Solution:
    def maxValue(self, n: str, x: int) -> str:
        def get_max(n, x):
            for i, c in enumerate(n):
                if c < x:
                    return n[:i] + x + n[i:]
            return n + x

        def get_min(n, x):
            for i, c in enumerate(n):
                if c > x:
                    if i != 0 or x != 0:
                        return n[:i] + x + n[i:]
            return n + x
        x = str(x)
        if n[0] != "-":
            return get_max(n,x)
        else:
            return "-" + get_min(n[1:], x)

提交代码评测得到：耗时72ms，占用内存15.8MB。

3. 题目三

给出题目三的试题链接如下：

1882. Process Tasks Using Servers

1. 解题思路

这一题事实上只需要不断地维护好当前的可用服务器列表以及使用中的服务器列表即可。

对于每一个任务，如果当前有可用的服务器，那么直接使用当前的可用服务器中最小weight的服务器即可，如果没有，那么需要等待第一个服务器被释放时（令时间为t）才能够进行运行，此时在等待队列中的任务一定是所有发生在t以及t之前的任务。

因此，我们只需要按照权重weight维护一个可用服务器列表，然后按照释放时间维护另一个使用服务器列表即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def assignTasks(self, servers: List[int], tasks: List[int]) -> List[int]:
        if len(servers) > 56:
            print(servers[56], servers[36])
        avaliable = [(w, idx) for idx, w in enumerate(servers)]
        heapq.heapify(avaliable)
        used = []
        t = 0
        res = []
        for i, d in enumerate(tasks):
            t = max(i, t)
            while used != [] and used[0][0] <= t:
                _, w, idx = heapq.heappop(used)
                heapq.heappush(avaliable, (w, idx))
            if avaliable == []:
                t = used[0][0]
                while used != [] and used[0][0] <= t:
                    _, w, idx = heapq.heappop(used)
                    heapq.heappush(avaliable, (w, idx))
            w, idx = heapq.heappop(avaliable)
            heapq.heappush(used, (t+d, w, idx))
            res.append(idx)
        return res

提交代码评测得到：耗时2156ms，占用内存57.7MB。

4. 题目四

给出题目四的试题链接如下：

1883. Minimum Skips to Arrive at Meeting On Time

1. 解题思路

这一题是看着答案搞定的，核心还是动态规划，关键问题就是怎么去定义这个动态规划问题。

我们开始给出的动态规划函数是考察每个到达每个位置时当前消耗的单次累计时间以及总的时间余量，不过这个方式会遇到超时问题，因为要记录的内容实在太多，并没有充分利用起历史的计算内容。

而官方给出的解答则是定义了动态规划函数 $d p (i, j)$ 表示到达第i个位置，且跳过j次时所需要的最短时间。

此时，我们有递推公式：

$\frac{dist_i}{speed}, \lceil{dp(i-1, j) + \frac{dist_i}{speed}}\rceil)$

而后，我们只需要看一下当 $i = n$ 时，j最小取到多少时能够满足 $d p (i, j)$ 不大于目标时间hoursBefore即可。

2. 代码实现

我们仿照官方解答给出python代码实线如下：

class Solution:
    def minSkips(self, dist: List[int], speed: int, hoursBefore: int) -> int:
        n = len(dist)
        dp = [[0 for _ in range(n+1)] for _ in range(n+1)]
        
        epsilon = 1e-8
        
        for i in range(1, n+1):
            dp[i][0] = dp[i-1][0] + math.ceil(dist[i-1]/speed)
            for j in range(1, i):
                dp[i][j] = min(dp[i-1][j-1] + dist[i-1]/speed, math.ceil(dp[i-1][j] + dist[i-1]/speed - epsilon))
            dp[i][i] = dp[i-1][i-1] + dist[i-1]/speed
        for i in range(n+1):
            if dp[n][i] <= hoursBefore:
                return i
        return -1