LeetCode笔记：Weekly Contest 288
Posted Espresso Macchiato
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了LeetCode笔记：Weekly Contest 288相关的知识，希望对你有一定的参考价值。
比赛链接：https://leetcode.com/contest/weekly-contest-288
1. 题目一
给出题目一的试题链接如下：
1. 解题思路
这一题思路挺直接的，找到奇偶数出现的位置，然后分别重新排序一下即可。
就是实现上稍微麻烦一点。
2. 代码实现
给出python代码实现如下：
class Solution:
def largestInteger(self, num: int) -> int:
odd, odd_digits = [], []
even, even_digits = [], []
flag =1
while num != 0:
if num % 2 == 0:
even.append((num % 10))
even_digits.append(flag)
else:
odd.append(num % 10)
odd_digits.append(flag)
num = num // 10
flag *= 10
odd = sorted(odd)
even = sorted(even)
res = 0
for x, d in zip(odd, odd_digits):
res += x*d
for x, d in zip(even, even_digits):
res += x*d
return res
提交代码评测得到：耗时61ms，占用内存13.7MB。
2. 题目二
给出题目二的试题链接如下：
1. 解题思路
这一题的思路同样也很直接，找到所有可以插入括号的位置然后遍历一下就行。
同样只是实现上多少有些繁琐。
2. 代码实现
给出python代码实现如下：
class Solution:
def minimizeResult(self, expression: str) -> str:
n = len(expression)
idx = expression.find("+")
_min = math.inf
res = ""
for i in range(idx):
for j in range(idx+2, n+1):
x = expression[:i]
m = expression[i:j]
y = expression[j:]
expr = (x + "*(" + m + ")*" + y).strip("*")
# print(expr, eval(expr))
if eval(expr) < _min:
res = x + "(" + m + ")" + y
_min = eval(expr)
return res
提交代码评测得到：耗时60ms，占用内存13.9MB。
3. 题目三
给出题目三的试题链接如下：
1. 解题思路
这一题同样没啥好说的，用二分法找到给定k的情况下能够把较小的数全部尽可能地平均放大的上限即可。
同样是实现比较麻烦，主要就是边界条件需要注意一下。
2. 代码实现
给出python代码实现如下：
class Solution:
def maximumProduct(self, nums: List[int], k: int) -> int:
MOD = 10**9 + 7
nums = sorted(nums)
cumsum = list(accumulate(nums))
n = len(nums)
i, j = nums[0], ceil((k + cumsum[-1]) / len(nums)) + 1
while j-i > 1:
m = (i+j) // 2
idx = bisect.bisect_right(nums, m)
delta = idx * m - cumsum[idx-1]
if delta > k:
j = m
else:
i = m
idx = bisect.bisect_right(nums, i)
j = k + cumsum[idx-1] - i * (idx)
res = 1
for _ in range(j):
res = res * (i+1) % MOD
for _ in range(idx-j):
res = res * i % MOD
for x in nums[idx:]:
res = res * x % MOD
return res
提交代码评测得到：耗时1311ms，占用内存26.1MB。
4. 题目四
给出题目四的试题链接如下：
1. 解题思路
这一题没能搞定，一直遇到超时问题，实在是放弃了。
这里仅仅抛砖引玉一下，给出我的超时code如下：
class Solution:
def maximumBeauty(self, flowers: List[int], newFlowers: int, target: int, full: int, partial: int) -> int:
flowers = sorted(flowers)
cumsum = [0] + list(accumulate(flowers))
n = len(flowers)
m = bisect.bisect_left(flowers, target)
if m == 0:
return n * full
def get_max_min(bound, k):
if bound == 0:
return 0
i, j = flowers[0], target
while j-i > 1:
mid = (i+j) // 2
idx = bisect.bisect_right(flowers[:bound], mid)
delta = idx * mid - cumsum[idx]
if delta > k:
j = mid
else:
i = mid
return i
res = 0
for i in range(m, -1, -1):
delta = target * (m-i) - (cumsum[m] - cumsum[i])
if delta > newFlowers:
break
remain = min(newFlowers - delta, newFlowers)
res = max(res, (n-i) * full + get_max_min(i, remain) * partial)
return res
后续也有尝试过认为0到m之间为一个单一高峰的数据分布，从而可以用二分法进行优化加速，不过实现之后发现这个单一峰值的假设是错误的，然后我就没招了，实在想不到什么方法可以优化后面那个遍历……
以上是关于LeetCode笔记：Weekly Contest 288的主要内容，如果未能解决你的问题，请参考以下文章