leecode
huawei0506 3
import collections
n = int(input().strip())
k = int(input().strip())
k_list = list(map(int,input().strip().split()))
k_list = [(k_list[i],k_list[i+1]) for i in range(len(k_list))if i %2 == 0]
girl_boy = list(map(int,input().strip().split()))
girl = girl_boy[:2]
boy = girl_boy[2:]
map_ = []
for i in range(n):
line = list(input().strip().split())
map_.append(line)
q = collections.deque()
# 添加时间维度，判断第几层,适用于bfs中需要判断层次的题目
q.append((boy[0],boy[1],0))
flag = True
while len(q) != 0:
if flag == False:
break
tmpx,tmpy,time = q.popleft()
for pulsx,plusy in [0,0],[0,1],[1,0],[-1,0],[0,-1]:
x = tmpx+pulsx
y = tmpy+plusy
if x >=n or y >=n or x < 0 or y < 0:
continue
elif map_[x][y][(time+1)%3] == '1' or (x,y) in k_list:
continue
else:
if [x,y] == girl:
flag =False
break
else:
q.append((x,y,time+1))
print(time+1)
leecode 121
# 交易一次，套用交易k次的板子
class Solution:
def maxProfit(self, prices):
# k笔交易
# 2*k个变量
k = 1
l = prices
buy_list = [-l[0]]*k
sell_list = [0]*k
if len(l) == 1:
return 0
else:
for i in range(1,len(l)):
for j in range(k):
if j == 0:
buy_list[j] = max(buy_list[j],-l[i])
sell_list[j] = max(sell_list[j],buy_list[j]+l[i])
else:
buy_list[j] = max(buy_list[j],sell_list[j-1]-l[i])
sell_list[j] = max(sell_list[j],buy_list[j]+l[i])
return max(sell_list)
if __name__ == "__main__":
prices = [1,4,2]
solution = Solution()
ans = solution.maxProfit(prices)
print(ans)
leecode122
# 任意交易，连个变量，类似于k次交易的板子，只不过对第一次交易不用特殊处理，因为
# 这个板子用两个变量存储了多次交易的收益，没有数组就不存在溢出的风险
#dp1 dp0分别代表买了股票和卖了股票
class Solution:
def maxProfit(self, prices: List[int]) -> int:
l = prices
dp0 = -l[0]
dp1 = 0
if len(l) == 1:
return 0
for i in range(1,len(l)):
dp0,dp1= max(dp0,dp1-l[i]),max(dp0+l[i],dp1)
return dp1
leecode123
# 两笔交易
# 3 3 5 0 0 3 1 4
# 6
# 四个转移变量
# 套用k次交易的板子
class Solution:
def maxProfit(self, prices):
# k笔交易
# 2*k个变量
k = 2
l = prices
buy_list = [-l[0]]*k
sell_list = [0]*k
if len(l) == 1:
return 0
else:
for i in range(1,len(l)):
for j in range(k):
if j == 0:
buy_list[j] = max(buy_list[j],-l[i])
sell_list[j] = max(sell_list[j],buy_list[j]+l[i])
else:
buy_list[j] = max(buy_list[j],sell_list[j-1]-l[i])
sell_list[j] = max(sell_list[j],buy_list[j]+l[i])
return max(sell_list)
leecode188
# k笔交易
# 2*k个变量
# 注意临界值的处理 j == 0（第一次交易），用了数组来存储，
# k次交易的收益，存在溢出风险
class Solution:
def maxProfit(self, k: int, prices: List[int]) -> int:
# k笔交易
# 2*k个变量
l = prices
buy_list = [-l[0]]*k
sell_list = [0]*k
if len(l) == 1:
return 0
else:
for i in range(1,len(l)):
for j in range(k):
if j == 0:
buy_list[j] = max(buy_list[j],-l[i])
sell_list[j] = max(sell_list[j],buy_list[j]+l[i])
else:
buy_list[j] = max(buy_list[j],sell_list[j-1]-l[i])
sell_list[j] = max(sell_list[j],buy_list[j]+l[i])
return max(sell_list)
leecode309
# 任意交易且包含冷冻期，套用任意交易的板子
# dp0 dp1分别代表买了股票和卖了股票的收入，,dp2存储t-2时刻的卖出股票的收入
class Solution:
def maxProfit(self, prices):
l = prices
dp0 = -l[0]
dp1 = 0
dp2 = 0
if len(l) == 1:
return 0
for i in range(1,len(l)):
dp0 = max(dp0,-l[i] +(dp2 if i>1 else 0))
# 要注意dp2的位置
dp2 = dp1
dp1 = max(dp1,dp0+l[i])
return dp1
leecode 741
#和任意次数交易一样，只需要减去手续费
class Solution:
def maxProfit(self, prices, fee) -> int:
l = prices
dp0 = -l[0]
dp1 = 0
if len(l) == 1:
return 0
for i in range(1,len(l)):
dp0,dp1= max(dp0,dp1-l[i]),max(dp0+l[i]-fee,dp1)
return dp1
快排求top-k
import random
class Solution:
def findKthLargest(self, nums, k):
l = 0
r = len(nums) - 1
target = len(nums) - k
while True:
piviotIndex = self.partion(l,r,nums)
if piviotIndex == target:
return nums[piviotIndex]
elif piviotIndex > target:
r = piviotIndex - 1
else:
l = piviotIndex + 1
def partion(self,l,r,nums):
randomindex = random.randint(l,r)
nums[l],nums[randomindex] = nums[randomindex],nums[l]
piviot = nums[l]
piviot_index = l
# 不能丢，否则容易超时
l = l + 1
while True:
while l<=r and nums[l] < piviot:
l += 1
while l<=r and nums[r] > piviot:
r -= 1
if l >= r:
break
nums[l],nums[r] = nums[r],nums[l]
# 不能丢，否则容易超时，特别是没有走上面两个循环的时候
l += 1
r -= 1
nums[r],nums[piviot_index] = nums[piviot_index],nums[r]
return r
if __name__ == "__main__":
solution = Solution()
nums = [3,2,1,5,6,4]
k = 2
ans = solution.findKthLargest(nums,k)
print(ans)