leetcode 贪心_Leetcode-贪心

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易(多次买卖一支股票)。

注意：你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。

解：

dfs，找到所有可能买入卖出情况，O(2n)，搜索的限制条件太少，递归层数太多，肯定超时。

class Solution:

def maxProfit(self, prices: List[int]) -> int:

def dfs(prices, s):

if s > len(prices):

return 0

res = 0

for start in range(s, len(prices)):

max_profit = 0

for end in range(start+1, len(prices)):

if prices[start] < prices[end]: # 如果当前的卖出高于买入，就卖出，从当前end卖出的整体收益等于这次卖出的收益+从下一天开始继续操作的收益

profit = prices[end] - prices[start] + dfs(prices, end+1)

if profit > max_profit:

max_profit = profit # 记录从start买入，不同点卖出的最大收益

if max_profit > res:

res = max_profit # 记录从不同点买入的最大收益

return res

return dfs(prices, 0)

贪心，因为可以多次买入卖出，找出那些共同使得利润最大化的买入及卖出价格即可。只要第二天股价涨了，就在当天买入第二天卖掉。O(N)

class Solution:

def maxProfit(self, prices: List[int]) -> int:

if not prices:

return 0

p = 0

for i in range(1, len(prices)):

cur = prices[i] - prices[i-1]

if cur > 0:

p += cur

return p if p else 0

动态规划，只要第二天涨了，卖了就赚了，否则就持有。记录每一天的状态记录最大利润，状态转移方程为：dp[i] = dp[i-1]  if prices[i] <= prices[i-1] else dp[i-1] + prices[i] -prices[i-1]，遍历一次即可，O(n)

def maxProfit(self, prices: List[int]) -> int:

if not prices:

return 0

n = len(prices)

dp = [0]*n

for i in range(1, n):

if prices[i] > prices[i-1]:

dp[i] = dp[i-1] + prices[i] -prices[i-1]

else:

dp[i] = dp[i-1]

return max(dp)

但其实不需要单独开一个数组，因为只要所有状态中最大的即可。写出来发现跟贪心就一样了。

class Solution:

def maxProfit(self, prices: List[int]) -> int:

if not prices:

return 0

n = len(prices)

res = 0

for i in range(1, n):

if prices[i] > prices[i-1]:

res = res + prices[i] - prices[i-1]

else:

continue

return res

在柠檬水摊上，每一杯柠檬水的售价为 5 美元。

顾客排队购买你的产品，(按账单 bills 支付的顺序)一次购买一杯。

每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。

注意，一开始你手头没有任何零钱。

如果你能给每位顾客正确找零，返回 true ，否则返回 false 。

提示：

0 <= bills.length <= 10000

bills[i] 不是 5 就是 10 或是 20

解：

模拟过程，贪心策略在于要尽可能多留5元在手里

class Solution:

def lemonadeChange(self, bills: List[int]) -> bool:

if not bills:

return True

five, ten = 0, 0

for bill in bills:

if bill == 5: # 如果付5元，不用管

five += 1

elif bill == 10: # 如果付10元，手里必须要有5元可以找

if not five:

return False

ten += 1

five -= 1

elif bill == 20: # 如果付20元，手里必须要有3张5元或1张5元1张10元可以找，贪心策略在于要尽可能的多留5元在手上

if ten and five: # 先走5+10的方案

ten -= 1

five -= 1

elif five >= 3:

five -= 3

else:

return False

return True

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。对每个孩子 i ，都有一个胃口值 gi ，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j ，都有一个尺寸 sj 。如果 sj >= gi ，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

注意：

你可以假设胃口值为正。

一个小朋友最多只能拥有一块饼干。

解：

贪心，先把g和s都sort一下。对g和s分别维护一个索引。如果当前sj可以满足gi，res、i、j都加1；否则的话饼干的索引+1(换个更大的饼干)。如果最大的sj都比gi小，说明后面的gi已经不可能被满足，直接返回结果。

class Solution:

def findContentChildren(self, g: List[int], s: List[int]) -> int:

if not g or not s:

return 0

g.sort()

s.sort()

i, j, res = 0, 0, 0

while i < len(g) and j < len(s):

if s[-1] < g[i]:

return res

if s[j] >= g[i]:

res += 1

i += 1

j += 1

else:

j += 1

return res

机器人在一个无限大小的网格上行走，从点 (0, 0) 处开始出发，面向北方。该机器人可以接收以下三种类型的命令：

-2：向左转 90 度

-1：向右转 90 度

1 <= x <= 9：向前移动 x 个单位长度

在网格上有一些格子被视为障碍物。

第 i 个障碍物位于网格点  (obstacles[i][0], obstacles[i][1])

如果机器人试图走到障碍物上方，那么它将停留在障碍物的前一个网格方块上，但仍然可以继续该路线的其余部分。

返回从原点到机器人的最大欧式距离的平方。

提示：

0 <= commands.length <= 10000

0 <= obstacles.length <= 10000

-30000 <= obstacle[i][0] <= 30000

-30000 <= obstacle[i][1] <= 30000

答案保证小于 2 ^ 31

解：

按照题目要求模拟，把方向表示和step的索引结合起来用，注意障碍的位置用hashset存一下，每次查询就O(1)。

class Solution:

def robotSim(self, commands: List[int], obstacles: List[List[int]]) -> int:

if not commands:

return 0

direct = 0 # 初始面向北方 1: 东；2:南；3:西

res = 0

loc = (0, 0) # 初始位于原点，direct = 0, y+step; 1，x+step; 2, y-step; 3, x-step

step_x = (0, 1, 0, -1)

step_y = (1, 0, -1, 0)

obstacles = set(map(tuple, obstacles))

for v in commands:

if v == -1: # 向右转90度

direct += 1

direct %= 4

elif v == -2: # 向左转90度

direct += 3 # -1+4

direct %= 4

else: # 前进

while v:

if (loc[0]+step_x[direct], loc[1]+step_y[direct]) in obstacles:

break

loc = (loc[0]+step_x[direct], loc[1]+step_y[direct])

res = max(res, loc[0]**2 + loc[1]**2)

v -= 1

return res