记录了初步解题思路 以及本地实现代码；并不一定为最优 也希望大家能一起探讨 一起进步
目录
-
-
- [3/31 2278. 字母在字符串中的百分比](#3/31 2278. 字母在字符串中的百分比)
- [4/1 2140. 解决智力问题](#4/1 2140. 解决智力问题)
- [4/2 2873. 有序三元组中的最大值 I](#4/2 2873. 有序三元组中的最大值 I)
- [4/3 2874. 有序三元组中的最大值 II](#4/3 2874. 有序三元组中的最大值 II)
- [4/4 1123. 最深叶节点的最近公共祖先](#4/4 1123. 最深叶节点的最近公共祖先)
- [4/5 1863. 找出所有子集的异或总和再求和](#4/5 1863. 找出所有子集的异或总和再求和)
- [4/6 368. 最大整除子集](#4/6 368. 最大整除子集)
-
3/31 2278. 字母在字符串中的百分比
遍历 求出字母个数
python
def percentageLetter(s, letter):
"""
:type s: str
:type letter: str
:rtype: int
"""
num = 0
n=len(s)
for c in s:
if c==letter:
num+=1
return num*100//n4/1 2140. 解决智力问题
一眼动归
因为对于某个位置i是否可以解决取决于他前面的问题 所以从后往前遍历更加方便
定义dp[i]为解决i~n之间的问题可以得到的最高分数
dp[i]=points[i]+dp[i+brainpower[i]+1]
python
def mostPoints(questions):
"""
:type questions: List[List[int]]
:rtype: int
"""
n=len(questions)
dp=[0]*(n+1)
for i in range(n-1,-1,-1):
dp[i]=max(dp[i+1],questions[i][0]+dp[min(n,i+questions[i][1]+1)])
return dp[0]4/2 2873. 有序三元组中的最大值 I
1.遍历 三重循环
2.为了使值最大 对于每个j 要找到它左边的最大值nums[i] 和右边的最大值nums[k]
lmax[j],rmax[j]分别记录j左右的最大值
python
def maximumTripletValue(nums):
"""
:type nums: List[int]
:rtype: int
"""
cur = 0
n=len(nums)
for i in range(n-2):
for j in range(i+1,n-1):
for k in range(j+1,n):
cur=max(cur,(nums[i]-nums[j])*nums[k])
return cur
def maximumTripletValue2(nums):
"""
:type nums: List[int]
:rtype: int
"""
n=len(nums)
lmax=[0]*n
rmax=[0]*n
for i in range(1,n):
lmax[i]=max(lmax[i-1],nums[i-1])
rmax[n-1-i]=max(rmax[n-i],nums[n-i])
cur=0
for j in range(1,n-1):
cur=max(cur,(lmax[j]-nums[j])*rmax[j])
return cur4/3 2874. 有序三元组中的最大值 II
数组长度很大不能循环遍历
为了使值最大 对于每个j 要找到它左边的最大值nums[i] 和右边的最大值nums[k]
lmax[j],rmax[j]分别记录j左右的最大值
python
def maximumTripletValue(nums):
"""
:type nums: List[int]
:rtype: int
"""
n=len(nums)
lmax=[0]*n
rmax=[0]*n
for i in range(1,n):
lmax[i]=max(lmax[i-1],nums[i-1])
rmax[n-1-i]=max(rmax[n-i],nums[n-i])
cur=0
for j in range(1,n-1):
cur=max(cur,(lmax[j]-nums[j])*rmax[j])
return cur4/4 1123. 最深叶节点的最近公共祖先
dfs
python
class TreeNode(object):
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
def lcaDeepestLeaves(root):
"""
:type root: Optional[TreeNode]
:rtype: Optional[TreeNode]
"""
global ans,maxd
ans=None
maxd = -1
def dfs(node,dep):
global ans,maxd
if not node:
maxd = max(maxd,dep)
return dep
left = dfs(node.left,dep+1)
right = dfs(node.right,dep+1)
if left==right==maxd:
ans = node
return max(left,right)
dfs(root,0)
return ans4/5 1863. 找出所有子集的异或总和再求和
遍历
python
def subsetXORSum(nums):
"""
:type nums: List[int]
:rtype: int
"""
ans=0
n=len(nums)
for i in range(1<<n):
tmp=0
for j in range(n):
if i&(1<<j):
tmp^=nums[j]
ans+=tmp
return ans4/6 368. 最大整除子集
- 遍历
ans内每个num结尾都一个备选答案
每一个数 遍历当前备选答案 保留长度最大的一个为当前Num的备选答案
2.dp
dp[i] nums[i]最大子集个数
python
def largestDivisibleSubset(nums):
"""
:type nums: List[int]
:rtype: List[int]
"""
n = len(nums)
nums.sort()
ans = [[nums[0]]]
for i in range(1,n):
c = nums[i]
ret = []
for j in range(len(ans)-1,-1,-1):
tmp = ans[j][:]
if c%tmp[-1]==0:
tmp.append(c)
if len(tmp)>len(ret):
ret = tmp[:]
if not ret:
ret = [c]
ans.append(ret)
ans.sort(key=lambda x: len(x))
return ans[-1]
def largestDivisibleSubset2(nums):
"""
:type nums: List[int]
:rtype: List[int]
"""
n=len(nums)
nums.sort()
dp = [1]*n
msize,mval=1,1
for i in range(n):
for j in range(i):
if nums[i]%nums[j]==0 and dp[j]+1>dp[i]:
dp[i]=dp[j]+1
if dp[i]>msize:
msize=dp[i]
mval = nums[i]
if msize==1:
return nums[:1]
ret = []
for i in range(n-1,-1,-1):
if msize==0:
return ret
if dp[i]==msize and mval%nums[i]==0:
ret.append(nums[i])
mval = nums[i]
msize-=1
return ret