LeetCode笔记：Weekly Contest 335
Posted Espresso Macchiato
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了LeetCode笔记：Weekly Contest 335相关的知识，希望对你有一定的参考价值。
1. 题目一
给出题目一的试题链接如下：
1. 解题思路
这一题还是蛮简单的，假设一共n个人，那么一次单向传递就是n-1次，因此我们将time对n-1取余，就是其有效的传递次数，然后time对n-1取整，就可以判断最后一次是正向传的还是反向传的。
结合二者，我们就能最终得到最后的枕头位置了。
2. 代码实现
给出python代码实现如下：
class Solution:
def passThePillow(self, n: int, time: int) -> int:
d = time % (n-1)
e = time // (n-1)
if e % 2 == 0:
return d + 1
else:
return n - d
提交代码评测得到：耗时29ms，占用内存13.8MB。
2. 题目二
给出题目二的试题链接如下：
1. 解题思路
这一题也很简单，通过遍历我们就能够快速地得到每一层的元素之和，然后对其排个序然后找到第k大的值即可。
2. 代码实现
给出python代码实现如下：
class Solution:
def kthLargestLevelSum(self, root: Optional[TreeNode], k: int) -> int:
s = defaultdict(int)
def dfs(root, level):
if root is None:
return
s[level] += root.val
dfs(root.left, level+1)
dfs(root.right, level+1)
return
dfs(root, 0)
s = sorted(s.values(), reverse=True)
if len(s) < k:
return -1
return s[k-1]
提交代码评测得到：耗时648ms，占用内存147.5MB。
3. 题目三
给出题目三的试题链接如下：
1. 解题思路
这一题我们的思路还是蛮暴力的。
要使得两侧元素互质，那么就要求两边元素没有共同的质因子，因此，我们只需要统计所有的元素当中质因子出现的次数，然后从头开始遍历，如果到某一个位置上，所有出现过的质因子后续都不会再出现，那么这个位置就是一个有效的切割位置，我们只要返回第一个有效切分位置即可。
这里的难度仅仅在于计算效率而已。
2. 代码实现
给出python代码实现如下：
@lru_cache(None)
def get_primes():
primes = []
status = [0 for _ in range(10**6)]
for i in range(2, 10**6):
if status[i] == 1:
continue
primes.append(i)
for j in range(i, 10**6, i):
status[j] = 1
return primes
class Solution:
primes = get_primes()
primes_set = set(primes)
def findValidSplit(self, nums: List[int]) -> int:
cnt = defaultdict(int)
for x in nums:
for p in self.primes:
if x in self.primes_set:
cnt[x] += 1
break
if p > x:
break
while x % p == 0:
cnt[p] += 1
x = x // p
s = defaultdict(int)
for i, x in enumerate(nums[:-1]):
for p in self.primes:
if x in self.primes_set:
s[x] += 1
break
if p > x:
break
while x % p == 0:
s[p] += 1
x = x // p
if all(s[k] == cnt[k] for k in s):
return i
return -1
提交代码评测得到：耗时747ms，占用内存24.9MB。
4. 题目四
给出题目四的试题链接如下：
1. 解题思路
这一题讲道理思路上来说反而更加直接，就是一个动态规划，直接做就行了……
2. 代码实现
给出python代码实现如下：
class Solution:
def waysToReachTarget(self, target: int, types: List[List[int]]) -> int:
MOD = 10**9+7
types = sorted(types, key=lambda x: (x[1], x[0] * x[1]), reverse=True)
n = len(types)
@lru_cache(None)
def dp(idx, tgt):
if tgt == 0:
return 1
if idx >= n:
return 0
res, s = 0, 0
for _ in range(types[idx][0] + 1):
res = (res + dp(idx+1, tgt-s)) % MOD
s += types[idx][1]
if s > tgt:
break
return res
return dp(0, target)
提交代码评测得到：耗时3133ms，占用内存133.8MB。
以上是关于LeetCode笔记：Weekly Contest 335的主要内容，如果未能解决你的问题，请参考以下文章