455.分发饼干
假设你是一位很棒的家长,想要给你的孩子们一些小饼干。但是,每个孩子最多只能给一块饼干。
对每个孩子 i,都有一个胃口值 g[i],这是能让孩子们满足胃口的饼干的最小尺寸;并且每块饼干 j,都有一个尺寸 s[j] 。如果 s[j] >= g[i],我们可以将这个饼干 j 分配给孩子 i ,这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子,并输出这个最大数值。
class Solution(object):
def findContentChildren(self, g, s):
gi = 0
si = 0
g.sort()
s.sort()
while gi < len(g) and si < len(s):
if s[si] >= g[gi]:
gi += 1
si += 1
return gi
435.无重叠区间
给定一个区间的集合 intervals ,其中 intervals[i] = [starti, endi] 。返回 需要移除区间的最小数量,使剩余区间互不重叠 。
class Solution(object):
def eraseOverlapIntervals(self, intervals):
# 对intervals列表按照每个子列表的第一个元素进行排序
intervals.sort(key=lambda x: x[0])
result = 0
# 遍历每一个子列表
for i in range(1,len(intervals)):
pre = intervals[i-1]
cur = intervals[i]
# cur左端点的值大于pre右端点的值 则证明不重合
if cur[0] < pre[1]:
result += 1
#
intervals[i][1] = min(intervals[i-1][1], intervals[i][1])
return result
# 视频解析
# https://www.bilibili.com/video/BV1A14y1c7E1/?spm_id_from=333.337.search-card.all.click&vd_source=5333ba15b46a8415fced47b74162923f
452. 用最少数量的箭引爆气球
有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points ,其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。你不知道气球的确切 y 坐标。
一支弓箭可以沿着 x 轴从不同点 完全垂直 地射出。在坐标 x 处射出一支箭,若有一个气球的直径的开始和结束坐标为 xstart,xend, 且满足 xstart ≤ x ≤ xend,则该气球会被 引爆 。可以射出的弓箭的数量 没有限制 。 弓箭一旦被射出之后,可以无限地前进。
给你一个数组 points ,返回引爆所有气球所必须射出的 最小 弓箭数 。
class Solution(object):
def findMinArrowShots(self, points):
points.sort(key = lambda x:x[0])
result = 0
for i in range (1, len(points)):
pre = points[i-1]
cur = points[i]
if cur[0] <= pre[1]: # 如果区间重合 result就+1
result += 1
points[i][1] = min(points[i-1][1],points[i][1])
l = len(points )
return l - result
406. 根据身高重建队列
假设有打乱顺序的一群人站成一个队列,数组 people 表示队列中一些人的属性(不一定按顺序)。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ,前面 正好 有 ki 个身高大于或等于 hi 的人。
请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ,其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性(queue[0] 是排在队列前面的人)。
class Solution(object):
def reconstructQueue(self, people):
# 对于两个维度要考虑 首先考虑其中一个维度
# -x[0] 表示对第一个值取负值,即进行降序排序。
# 正数的负值是其相反数,负数的负值是其本身,因此对第一个值取负值后,会按照第一个值进行降序排序。
people.sort(key = lambda x:(-x[0], x[1]))
# x[1] 表示对第二个值进行升序排序
res = []
for p in people:
# 获取位置 p[1]
if len(res) <= p[1]: #
# append 用于向列表的末尾添加一个元素
res.append(p) # 添加到队尾的位置
elif len(res) > p[1]:
# insert在指定位置插入一个元素
res.insert(p[1], p)
return res
121. 买卖股票的最佳时机
给定一个数组 prices ,它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票,并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润,返回 0 。
class Solution(object):
def maxProfit(self, prices):
cost, profit = float('+inf'), 0
for price in prices:
cost = min(cost, price) # 找最小的花费
profit = max(profit, price - cost) # 利润
return profit
122. 买卖股票的最佳时机 II
给你一个整数数组 prices ,其中 prices[i] 表示某支股票第 i 天的价格。
在每一天,你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买,然后在 同一天 出售。
返回 你能获得的 最大 利润 。
class Solution(object):
def maxProfit(self, prices):
profit = 0 #总利润
tmp = 0 # 暂时利润
for i in range(1, len(prices)):
tmp = prices[i] - prices[i-1]
# 股票连续上升可以分解为每天都上升
if tmp > 0:
profit += tmp
return profit
605. 种花问题
假设有一个很长的花坛,一部分地块种植了花,另一部分却没有。可是,花不能种植在相邻的地块上,它们会争夺水源,两者都会死去。
给你一个整数数组 flowerbed 表示花坛,由若干 0 和 1 组成,其中 0 表示没种植花,1 表示种植了花。另有一个数 n ,能否在不打破种植规则的情况下种入 n 朵花?能则返回 true ,不能则返回 false 。
class Solution(object):
def canPlaceFlowers(self, flowerbed, n):
# 若当前地的前面和后面都为0,则该地可以种花
# 考虑边界问题 最前面和最后面赋值为0
count = 0
flowerbed.insert(0,0)
flowerbed.append(0)
for i in range(1,len(flowerbed)-1):
if flowerbed[i]==0 and flowerbed[i-1]==0 and flowerbed[i+1]==0:
flowerbed[i] = 1 # 要先标记此处种花
i += 2 #该位置可以种花 则下个位置肯定不能种花 直接跳到下下个位置进行判断
count += 1
else:
i += 1
return count>=n
392. 判断子序列
给定字符串 s 和 t ,判断 s 是否为 t 的子序列。
class Solution(object):
def isSubsequence(self, s, t):
i = j = 0
slen = len(s)
tlen = len(t)
while i < slen and j < tlen:
if s[i] == t[j]:
i += 1
j += 1
return i == slen
655.非递减数列
给你一个长度为 n 的整数数组 nums ,请你判断在 最多 改变 1 个元素的情况下,该数组能否变成一个非递减数列。
class Solution(object):
def checkPossibility(self, num):
N = len(num)
count = 0
for i in range(1, N):
if num[i-1] > num[i]:
count += 1
# num[i-2] > num[i] 这种情况需要 num[i] = num[i-1]
# 相反的话 num[i-2] <= num[i] 就num[i-1] = num[i]
if i==1 or num[i-2] <= num[i]:
num[i-1] = num[i]
else:
# 尽量改前面那个值 因为不知道后面的元素是什么
num[i] = num[i-1]
return count <= 1
53. 最大子数组和
给你一个整数数组 nums ,请你找出一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。
子数组
是数组中的一个连续部分。
# 用动态规划的思路做 暂时没太懂
class Solution(object):
def maxSubArray(self, nums):
size = len(nums)
pre = 0
ans = nums[0]
for i in range(size):
pre = max(nums[i], pre + nums[i])
ans = max (ans, pre)
return ans
下面是贪心算法的版本
class Solution(object):
def maxSubArray(self, nums):
# 贪心算法
# 如果连续和A为负数 继续相加则只会让A+num[i]变小
# 不如将连续和的七点变为num[i]
size = len(nums)
ans = 0
lianxuhe = 0
for i in range(size):
lianxuhe += nums[i]
# 如果连续和小于0 就将下一个数作为新的起点进行累加
if lianxuhe > 0:
ans =max(lianxuhe, ans)
else:
lianxuhe = 0
return ans