记录了初步解题思路 以及本地实现代码;并不一定为最优 也希望大家能一起探讨 一起进步
从一位开始考虑
a结尾 前面可以为 e,i,u
e结尾 前面可以为 a,i
i结尾 前面可以为 e,o
o结尾 前面可以为 i
u结尾 前面可以为 i,o
def countVowelPermutation(n):
"""
:type n: int
:rtype: int
"""
MOD = 10**9+7
l = [1,1,1,1,1]
if n==1:
return sum(l)
for _ in range(n-1):
tmp = [0]*5
tmp[0] = (l[1]+l[2]+l[4])%MOD
tmp[1] = (l[0]+l[2])%MOD
tmp[2] = (l[1]+l[3])%MOD
tmp[3] = (l[2])%MOD
tmp[4] = (l[2]+l[3])%MOD
l = tmp[:]
return sum(l)%MOD
分钟共有2460种可能
根据抽屉原理 如果timePoints>2460 那么必定存在一对时间相同 答案为0
将时间转换为分钟 从小到大排序 比较相邻两数的时间差
def findMinDifference(timePoints):
"""
:type timePoints: List[str]
:rtype: int
"""
day = 24*60
if len(timePoints)>day:
return 0
def transform(s):
l = s.split(":")
ans = int(l[0])*60+int(l[1])
return ans
mem = set()
l = []
for s in timePoints:
num = transform(s)
if num in mem:
return 0
l.append(num)
l.sort()
ans = min(abs(l[-1]-l[0]),day-abs(l[-1]-l[0]))
for i in range(len(l)-1):
cur = min(l[i+1]-l[i],day-(l[i+1]-l[i]))
ans = min(ans,cur)
return ans
滑动窗口 保持k+1长度 记录长度内出现的数字个数
如果数字个数大于1 则成立
def containsNearbyDuplicate( nums, k):
"""
:type nums: List[int]
:type k: int
:rtype: bool
"""
from collections import defaultdict
win = defaultdict(int)
for i in range(min(len(nums),k+1)):
win[nums[i]]+=1
if win[nums[i]]>1:
return True
for i in range(k+1,len(nums)):
win[nums[i-k-1]]-=1
win[nums[i]]+=1
if win[nums[i]]>1:
return True
return False
石子总和被3整除为输 目标是尽可能不让和被3整除
将石子分为3类 余数为0,1,2
取余数为0的石子数 对总和没有影响 平稳换手
如果0的个数为偶数 不影响
为基数相当于调换先后手
为了使和不为3的倍数
如果A先取1 AB依次取112121212…
这种情况下 需要有1 但是2的个数需要大于1的个数
如果A先取2 AB依次取221212121…
这种情况下 需要有2 但是1的个数需要大于2的个数
综上
如果先手 1,2都至少有一个就可以赢
如果后手 需要1比2多超过两个 或者2比1多超过两个
def stoneGameIX(stones):
"""
:type stones: List[int]
:rtype: bool
"""
s0,s1,s2 = 0,0,0
for s in stones:
if s%3==0:
s0+=1
elif s%3==1:
s1+=1
else:
s2+=1
if s0%2==0:
return s1>0 and s2>0
return s1-s2>2 or s2-s1>2
BFS
valueToloc记录每个值的位置所在
对于arr[loc]=v
他可以到达 loc+1,loc-1或者valueToloc[v]中的所有位置
第一次搜索到必定是最少次数 visited记录被搜索到的位置
同个值的位置搜索过后之后不需要搜索这个地方 删除valueToloc[v]
def minJumps(arr):
"""
:type arr: List[int]
:rtype: int
"""
from collections import defaultdict,deque
valueToloc = defaultdict(list)
for loc,v in enumerate(arr):
valueToloc[v].append(loc)
n = len(arr)
l = deque()
l.append((0,0))
visited= set()
visited.add(0)
while l:
loc,step = l[0]
if loc==n-1:
return step
value = arr[loc]
l.popleft()
for tmp in valueToloc[value][::-1]:
if tmp not in visited:
visited.add(tmp)
l.append((tmp,step+1))
valueToloc[value]=[]
if loc+1<n and loc+1 not in visited:
visited.add(loc+1)
l.append((loc+1,step+1))
if loc-1>0 and loc-1 not in visited:
visited.add(loc-1)
l.append((loc-1,step+1))
如果s与s的倒序相同 一次即可以删除
因为只有a,b两种字母 所以第一次删除所有a 第二次删除所有b
最多两次就可以删完
def removePalindromeSub(s):
"""
:type s: str
:rtype: int
"""
if s==s[::-1]:
return 1
return 2
一个小顶堆记录最小值
一个大顶堆记录最大值
同时记录最值对应时间戳
一个哈希表记录时间戳的对应值
curr记录最新时间
如果从顶堆中取出最值 比较最值的时间戳在哈希表中的值是否一致
如果不一致说明这个值已经失效 舍弃
“”"
import heapq
class StockPrice(object):
def __init__(self):
self.min = []
self.max = []
heapq.heapify(self.min)
heapq.heapify(self.max)
self.curr = 0
self.m = {}
def update(self, timestamp, price):
"""
:type timestamp: int
:type price: int
:rtype: None
"""
self.curr = max(self.curr,timestamp)
if timestamp not in self.m:
self.m[timestamp] = price
heapq.heappush(self.min,(price,timestamp))
heapq.heappush(self.max,(-price,timestamp))
elif price!=self.m[timestamp]:
self.m[timestamp] = price
heapq.heappush(self.min,(price,timestamp))
heapq.heappush(self.max,(-price,timestamp))
def current(self):
"""
:rtype: int
"""
return self.m[self.curr]
def maximum(self):
"""
:rtype: int
"""
while True:
maxp,tp = self.max[0]
if self.m[tp]!=-maxp:
print(tp,self.m[tp],maxp)
heapq.heappop(self.max)
else:
return -maxp
def minimum(self):
"""
:rtype: int
"""
while True:
minp,tp = self.min[0]
if self.m[tp]!=minp:
heapq.heappop(self.min)
else:
return minp