[Leetcode] - 力扣第216场周赛

碎碎念

• 记录小熊猫第一次AC全部！Cheers! 为了这个特地开了CSDN，希望我能好好学习，找到工作^ ^
• 感觉这次全是数学题？还是脑筋急转弯的那种。。。
• 写完才觉得自己逻辑真的好差，说不清楚TT多写写会好起来吗（眼巴巴……

题目列表

1. 检查两个字符串数组是否相等 [3p]

给你两个字符串数组 word1 和 word2 。如果两个数组表示的字符串相同，返回 true ；否则，返回 false 。

数组表示的字符串 是由数组中的所有元素 按顺序 连接形成的字符串。

示例：
输入：word1 = [“ab”, “c”], word2 = [“a”, “bc”]
输出：true
解释：
word1 表示的字符串为 “ab” + “c” -> “abc”
word2 表示的字符串为 “a” + “bc” -> “abc”
两个字符串相同，返回 true

代码：

class Solution:
    def arrayStringsAreEqual(self, word1: List[str], word2: List[str]) -> bool:
        w1 = ''
        w2 = ''
        for i in word1:
            w1 += i
        for i in word2:
            w2 += i
        return w1 == w2

题解：直接加成两个字符串比价，简单题，过了！

2 具有给定数值的最小字符串 [4p]

小写字符 的 数值 是它在字母表中的位置（从 1 开始），因此 a 的数值为 1 ，b 的数值为 2 ，c 的数值为 3 ，以此类推。

字符串由若干小写字符组成，字符串的数值 为各字符的数值之和。例如，字符串 “abe” 的数值等于 1 + 2 + 5 = 8 。

给你两个整数 n 和 k 。返回 长度 等于 n 且 数值 等于 k 的 字典序最小 的字符串。

注意，如果字符串 x 在字典排序中位于 y 之前，就认为 x 字典序比 y 小，有以下两种情况：

x 是 y 的一个前缀；
如果 i 是 x[i] != y[i] 的第一个位置，且 x[i] 在字母表中的位置比 y[i] 靠前。

示例
输入：n = 3, k = 27
输出：“aay”
解释：字符串的数值为 1 + 1 + 25 = 27，它是数值满足要求且长度等于 3 的字典序最小的字符串。

代码：

class Solution:
    def getSmallestString(self, n: int, k: int) -> str:
        z_number = (k - n)//25
        a_number = n - z_number - 1
        tmp = k - z_number*26 - a_number
        # print(tmp)
        dic = list('abcdefghijklmnopqrstuvwxyz')
        result = 'a'*a_number + dic[tmp - 1] +'z'*z_number
        return result

题解：
z_number：z的数量
a_number：a的数量
为了字典序最小，应该最后全是z，前面全是a，中间留一个缓冲地带。因此答案会是“a”*a_number + tmp + “z”*z_number。
如何确定a_number和z_number？
每个位置都需要填入字母，因此首先考虑n个a，此时字符串数值为n，距离k还差k - n。把k - n分到z上，最多能产生 (k - n) // 25 个z，即 z_number = (k - n) // 25。
留一个缓冲区，tmp取值范围为{1,…,26}。
剩下的就是 a_number = n - z_number - 1
tmp = k - z_number * 26 - a_number
把tmp转换成字母，求和输出，pass！

3 生成平衡数组的方案数 [5p]

给你一个整数数组 nums 。你需要选择 恰好 一个下标（下标从 0 开始）并删除对应的元素。请注意剩下元素的下标可能会因为删除操作而发生改变。

比方说，如果 nums = [6,1,7,4,1] ，那么：

选择删除下标 1 ，剩下的数组为 nums = [6,7,4,1] 。
选择删除下标 2 ，剩下的数组为 nums = [6,1,4,1] 。
选择删除下标 4 ，剩下的数组为 nums = [6,1,7,4] 。
如果一个数组满足奇数下标元素的和与偶数下标元素的和相等，该数组就是一个 平衡数组 。

请你返回删除操作后，剩下的数组 nums 是 平衡数组 的 方案数 。

示例 ：
输入：nums = [2,1,6,4]
输出：1
解释：
删除下标 0 ：[1,6,4] -> 偶数元素下标为：1 + 4 = 5 。奇数元素下标为：6 。不平衡。
删除下标 1 ：[2,6,4] -> 偶数元素下标为：2 + 4 = 6 。奇数元素下标为：6 。平衡。
删除下标 2 ：[2,1,4] -> 偶数元素下标为：2 + 4 = 6 。奇数元素下标为：1 。不平衡。
删除下标 3 ：[2,1,6] -> 偶数元素下标为：2 + 6 = 8 。奇数元素下标为：1 。不平衡。
只有一种让剩余数组成为平衡数组的方案。

代码：

class Solution:
    def waysToMakeFair(self, nums: List[int]) -> int:
        odd, even, b_num = 0, 0, 0
        times = (len(nums)+1)//2 if len(nums)% 2 == 0 else len(nums)//2
        for i in range(times):
            odd += nums[2*i+1]
            if 2*i+2 >= len(nums):
                break
            even += nums[2*i+2]
        if odd == even:
            b_num += 1
        for i in range(times):
            odd = odd - nums[2*i+1] + nums[2*i]
            if odd == even:
                b_num += 1
            if 2*i+2 >= len(nums):
                break
            even = even - nums[2*i+2] + nums[2*i+1]
            if odd == even:
                b_num += 1
        return b_num

题解：
首先考虑选择删除下标为0的元素，记录此时even和odd两个下标元素和，如果刚好相等，平衡数组方案（b_num) 加一。
然后用一个for循环，来遍历删除的元素。
如果选择删除一个下标为奇数的元素，等价于用前一个选择的数来替换它，所以此时odd = odd - nums [ 2 * i +1] + nums [ 2 * i]。判断一下是不是平衡。
同理，如果选择删除了下标为偶数的元素，等价于用前一个选择的数来替换它，even = even - nums [ 2 * i + 2] + nums [ 2*i + 1]。判断一下是不是平衡。
最后输出结果，pass！

4 完成所有任务的最少初始能量 [6p]

给你一个任务数组 tasks ，其中 tasks[i] = [actuali, minimumi] ：

actuali 是完成第 i 个任务 需要耗费 的实际能量。
minimumi 是开始第 i 个任务前需要达到的最低能量。
比方说，如果任务为 [10, 12] 且你当前的能量为 11 ，那么你不能开始这个任务。如果你当前的能量为 13 ，你可以完成这个任务，且完成它后剩余能量为 3 。

你可以按照 任意顺序 完成任务。

请你返回完成所有任务的 最少 初始能量。

示例 ：
输入：tasks = [[1,2],[2,4],[4,8]]
输出：8
解释：
一开始有 8 能量，我们按照如下顺序完成任务：
- 完成第 3 个任务，剩余能量为 8 - 4 = 4 。
- 完成第 2 个任务，剩余能量为 4 - 2 = 2 。
- 完成第 1 个任务，剩余能量为 2 - 1 = 1 。
注意到尽管我们有能量剩余，但是如果一开始只有 7 能量是不能完成所有任务的，因为我们无法开始第 3 个任务。

代码：

class Solution:
    def minimumEffort(self, tasks: List[List[int]]) -> int:
        tasks.sort(key = lambda x: x[1]-x[0])
        tmp = tasks.pop()
        initial = tmp[1]
        remaining = initial - tmp[0]
        while tasks:
            tmp = tasks.pop()
            if remaining < tmp[1]:
                initial += tmp[1] - remaining
                remaining = tmp[1]
            remaining -= tmp[0]
        return initial

题解：
先把任务排个序，按照minimun - actual来排序，这个差值越大越需要先趁能量高的时候处理掉，贪心的思路。

从差值最大的开始，令初始值等于minimun，处理完这个任务以后剩余的能量为remaining = minimum - actual.
然后处理下一个，如果remaining不够下一个的minimum了，就再追加能量到能够处理这个任务，把追加的能量加到initial上。
重复这个过程，直到所有任务都完成。

p.s.这题竟然是Hard……惊了Σ(っ °Д °;)っ