1.每日温度
给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指对于第 i 天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用 0 来代替。
示例 1:
输入: temperatures = [73,74,75,71,69,72,76,73]
输出: [1,1,4,2,1,1,0,0]
示例 2:
输入: temperatures = [30,40,50,60]
输出: [1,1,1,0]
示例 3:
输入: temperatures = [30,60,90]
输出: [1,1,0]
***方法一：***暴力法，其中前向暴力法比较好想，但是还是比较麻烦的，可以考虑后向遍历，这样后向的经验就可以为前向服务，大概逻辑是，右边的数字如果比当前数字大，那就是1，如果比你小或者和你相等，那就找他指向的那个数字，不断循环直到找到比他大的那个数
class Solution:
def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
n=len(temperatures)
res=[0]*n
for i in range(n-1,-1,-1):
if i==n-1:
continue
tmp=1
while temperatures[i+tmp]<=temperatures[i]:
if i+tmp==n-1: #写这一条的目的是为了让找不到更大的值的有一个归宿
res[i]=0
break
else:
if res[i+tmp]==0:
tmp+=1
else:
tmp+=res[i+tmp]
if temperatures[i+tmp]>temperatures[i]:
res[i]=tmp
return res
这个是我写的代码，我的条件写的有点复杂，但是我也不知道怎么优化，我的逻辑基本上就是按照上面的思路进行编写的，同时对很多异常情况进行了额外的处理，也就是堆屎山，chat根据我的思路进行了一些优化：
from typing import List
class Solution:
def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
n = len(temperatures)
res = [0] * n
for i in range(n - 2, -1, -1): # 从倒数第二个元素开始遍历
tmp = 1
while i + tmp < n and temperatures[i + tmp] <= temperatures[i]:
if res[i + tmp] == 0: # 如果后面没有比当前温度高的
tmp = 0
break
tmp += res[i + tmp] # 否则跳到下一个更高温度的位置
if tmp > 0: #可以不加这个判断没有意义
res[i] = tmp
return res
#下面的代码好一些，省去了一些不必要的判断
class Solution:
def dailyTemperatures(self,temperatures:List[int])->List[int]:
n=len(temperatures)
res=[0]*n
for i in range(n-2,-1,-1):
tmp=1
while temperatures[i]>=temperatures[i+tmp]:
if res[i+tmp]==0:
tmp=0
break
else:
tmp+=res[i+tmp]
res[i]=tmp
return res
chat的代码的逻辑确实会好一些，他的逻辑是这样的：
1.最后一个温度不需要遍历，在创建了res列表之后，遍历的时候直接从n-2开始，前向遍历
2.tmp默认是1，也就是说上来直接和下一个温度进行检查，如果当前下标加上tmp以后的温度仍然比当前温度低，那么就进入循环
3.上来就加限定条件，就跟回溯算法的pop弹出一样，上来就如果，当前在比较的目标温度指向的下一个温度已经没有了，也就是代码中的，res[tmp+i]已经空了，那么此时说明，我在判断的该温度已经是目前最大的温度了，所以，我直接把tmp改成0，然后break跳出这个循环
4.如果当前在对比的温度不满足当前温度的条件，他就给当前温度指一条明路，那就是你在tmp的基础上加一个res[i+tmp]，你去找他试试运气吧
5.循环结束以后，tmp就是指向了下一个更高的温度的距离，那么也就是该温度的res的值，也就是说，出了循环那就直接给这个res[i]赋值tmp
方法二:用栈来写
from typing import List
class Solution:
def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
n = len(temperatures)
res = [0] * n
stack = []
for i in range(n - 1, -1, -1):
while stack and temperatures[stack[-1]] <= temperatures[i]: #判断当前值和盘子里的最小值
stack.pop() #如果大就扔盘子找下一个，直到找到他合适的位置
if stack:
res[i] = stack[-1] - i #盘子里还有就作差值算数字
stack.append(i) #当前值一定入盘子，因为一定能给他在栈里找到一个合适的位置存放
return res
代码逻辑：
1.当i为n-1的时候，栈写进n-1
2.到n-2的时候，最后一个温度和当前温度比较，之后的温度小就进循环pop掉最后一个温度，然后res[i]=0，如果最后一个温度比他大，那么就不pop了，res[i]=1
3.之后的逻辑就是，进来一个数就先和栈里最小的先比较，如果比不上，那就结算，如果比最小的大，那就找栈里下一个，他的目标是把这个栈严格写成一个从大到小的顺序，如果当前数更大的，就把比这个数小的所有的盘子全部pop出去，下一次判断就以当前数为模板
具体的逻辑看我的注释，我是看明白了，但是这个代码也是那种，自己写很难写出来的逻辑，只能说看看热闹。如果有任何人有问题可以评论区留言，我将详细解答。
#2024.9.18
class Solution:
def dailyTemperatures(self,temperatures:List[int])->List[int]:
n=len(temperatures)
stack=[]
res=[0]*n
for i in range(n-1,-1,-1):
while stack and temperatures[stack[-1]]<=temperatures[i]: #栈中大
stack.pop()
if not stack:
stack.append(i)
continue
res[i]=stack[-1]-i
stack.append(i)
return res
#2024.9.29
from typing import List
class Solution:
def dailyTemperatures(self,temperatures:List[int])->List[int]:
n=len(temperatures)
stack=[]
res=[0]*n
for i in range(n-1,-1,-1):
while stack and temperatures[i]>=temperatures[stack[-1]]:
stack.pop()
if not stack:
stack.append(i)
continue
res[i]=stack[-1]-i
stack.append(i)
return res
其中for循环进去以后的逻辑如下：
1.如果stack中有东西，并且stack里的那个不满足要求，那就把stack弹一个出来，直到当前温度满足要求。
2.如果此时的stack已经空了，那就把当前的温度加进去，继续下一次循环
3.如果没空，那就给res一个合适的数，然后把当前值append进stack
2.等差数列划分
如果一个数列 至少有三个元素 ，并且任意两个相邻元素之差相同，则称该数列为等差数列。
例如，[1,3,5,7,9]、[7,7,7,7] 和 [3,-1,-5,-9] 都是等差数列。
给你一个整数数组 nums ，返回数组 nums 中所有为等差数组的 子数组 个数。
子数组 是数组中的一个连续序列。
示例 1：
输入：nums = [1,2,3,4]
输出：3
解释：nums 中有三个子等差数组：[1, 2, 3]、[2, 3, 4] 和 [1,2,3,4] 自身。
示例 2：
输入：nums = [1]
输出：0
***方法一：***暴力法
class Solution:
def numberOfArithmeticSlices(self, nums: List[int]) -> int:
res=[]
for left in range(0,len(nums)-2):
right=left+2
while right<len(nums):
if self.check(nums[left:right+1]):
res.append(nums[left:right+1])#注意这里的加一，加一是为了取到right
right+=1
else:
break
return len(res)
def check(self,nums)->bool:
if all(nums[i+1]-nums[i]==nums[i+2]-nums[i+1] for i in range(0,len(nums)-2)):
return True
else:
return False
方法二差分 + 计数
from typing import List
class Solution:
def numberOfArithmeticSlices(self, nums: List[int]) -> int:
n = len(nums)
if n == 1:
return 0
d, t = nums[0] - nums[1], 0 # 初始化公差d，以及等差数列的计数器t
ans = 0 # 最终结果，存储等差数列的数量
# 从第3个元素开始遍历，因为等差数列至少有三个元素
for i in range(2, n):
if nums[i - 1] - nums[i] == d: # 当前差值和之前差值d相等
t += 1 # 当前元素与前两个元素构成新的等差数列，t增加
else:
d = nums[i - 1] - nums[i] # 差值不相等，更新差值d
t = 0 # t归零，因为无法继续形成等差数列
ans += t # 每次都将t的值加到最终结果中
return ans
这个代码最巧的地方在于t+=1这里，我看这个代码的时候我心想这玩意加一有什么意义呢，每次发现一个新的元素，他要多好多子串呢，这咋能数的过来，但是其实很简单，比如三个元素的等差变四个元素的等差的时候就多了两种可能，四个元素变五个元素的时候就多了三种可能，是有规律的，所以这样遍历下来是合适的，只能说又是一个自己想是想不出来的题。还是暴力法来的直接。
3.累加数
累加数 是一个字符串，组成它的数字可以形成累加序列。
一个有效的 累加序列 必须 至少 包含 3 个数。除了最开始的两个数以外，序列中的每个后续数字必须是它之前两个数字之和。
给你一个只包含数字 ‘0’-‘9’ 的字符串，编写一个算法来判断给定输入是否是 累加数 。如果是，返回 true ；否则，返回 false 。
说明：累加序列里的数，除数字 0 之外，不会 以 0 开头，所以不会出现 1, 2, 03 或者 1, 02, 3 的情况。
示例 1：
输入：“112358”
输出：true
解释：累加序列为: 1, 1, 2, 3, 5, 8 。1 + 1 = 2, 1 + 2 = 3, 2 + 3 = 5, 3 + 5 = 8
示例 2：
输入：“199100199”
输出：true
解释：累加序列为: 1, 99, 100, 199。1 + 99 = 100, 99 + 100 = 199
这个题我建议与上次那个ip地址配合食用，非常的好，详细请看我在9.1日写的文章
from typing import List
class Solution:
def isAdditiveNumber(self, num: str) -> bool:
# 将seg_count用来表示段数
seg_count = len(num) # 使用整个字符串长度来作为循环的控制
def dfs(segId: int, segStart: int, segments: List[int]):
# 如果找到了所有段并且遍历完了字符串
if segId >= 3 and segStart == len(num):
if self.check(segments[:segId]):
return True
return False
# 如果已经遍历完了字符串但是还没有足够的段
if segStart == len(num):
return False
# 由于不能有前导零，如果当前数字为 0
if num[segStart] == "0":
segments[segId] = 0
return dfs(segId + 1, segStart + 1, segments)
addr = 0
for segEnd in range(segStart, len(num)):
addr = addr * 10 + int(num[segEnd])
segments[segId] = addr
if dfs(segId + 1, segEnd + 1, segments):
return True
return False
segments = [0] * seg_count
return dfs(0, 0, segments)
def check(self, nums: List[int]) -> bool:
# 检查每两个数相加是否等于第三个数
return all(nums[i] + nums[i + 1] == nums[i + 2] for i in range(len(nums) - 2))
这个代码是我根据昨天的代码修改而来的代码，这个代码的思路主要是dfs去遍历每种段，只要有一个是True，那就是True。看了下官方答案，这个题也是暴力法，我的方法未必不是好的，因为长度最多也就35个，所以这个题就是得用暴力法。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
