小白leetcode题解（只是自己想要记录自己的做题过程和收获，大三废物的努力日记）

最新推荐文章于 2024-09-11 22:27:08 发布

dhkkfy

最新推荐文章于 2024-09-11 22:27:08 发布

阅读量141

点赞数

文章标签： leetcode

本文链接：https://blog.csdn.net/LYNDDF/article/details/126911123

版权

1.给你一个非负整数数组 nums 。如果存在一个数 x ，使得 nums 中恰好有 x 个元素大于或者等于 x ，那么就称 nums 是一个特殊数组，而 x 是该数组的特征值。

注意： x 不必是 nums 的中的元素。

如果数组 nums 是一个特殊数组，请返回它的特征值 x 。否则，返回 -1 。可以证明的是，如果 nums 是特殊数组，那么其特征值 x 是唯一的。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/special-array-with-x-elements-greater-than-or-equal-x
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution(object):

def specialArray(self, nums):

nums.sort(reverse=True)

m=len(nums)

for i in range(1,m+1):

if nums[i-1]>=i and (i==m or nums[i]<i):

return i

return -1

理解：
首先将传入的数组进行降序排序，通过题目我们可知输入数组的特征值不会大于数组的长度，所以测量数组的长度，之后进行for 循环，只要满足取得的i满足nums[i-1]>=i同时也要满足此时的I==长度，或者满组nums[i]<i便可以。

如果字符串满足以下条件之一，则可以称之为有效括号字符串（valid parentheses string，可以简写为 VPS）：

字符串是一个空字符串 ""，或者是一个不为 "(" 或 ")" 的单字符。
字符串可以写为 AB（A 与 B 字符串连接），其中 A 和 B 都是有效括号字符串。
字符串可以写为 (A)，其中 A 是一个有效括号字符串。
类似地，可以定义任何有效括号字符串 S 的嵌套深度 depth(S)：

depth("") = 0
depth(C) = 0，其中 C 是单个字符的字符串，且该字符不是 "(" 或者 ")"
depth(A + B) = max(depth(A), depth(B))，其中 A 和 B 都是有效括号字符串
depth("(" + A + ")") = 1 + depth(A)，其中 A 是一个有效括号字符串
例如：""、"()()"、"()(()())" 都是有效括号字符串（嵌套深度分别为 0、1、2），而 ")(" 、"(()" 都不是有效括号字符串。

给你一个有效括号字符串 s，返回该字符串的 s 嵌套深度。

示例 1：

输入：s = "(1+(2*3)+((8)/4))+1"
输出：3
解释：数字 8 在嵌套的 3 层括号中。
示例 2：

输入：s = "(1)+((2))+(((3)))"
输出：3

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/maximum-nesting-depth-of-the-parentheses
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution(object):

def maxDepth(self, s):

ans,size=0,0

for ch in s:

if ch=='(':

size+=1

ans=max(ans,size)

elif ch==')':

size-=1

return ans

理解：
对于这道题，根据题意我们知道其实就是要计算输入的字符串中的括号的最大层数，因此我们可以通过两个变量来记载，ans,size，ans用来保存字符串中的最大的括号层数，size是则是通过判断是走括号还是有括号来进行加减，

给你一个字符串 s，请你返回两个相同字符之间的最长子字符串的长度，计算长度时不含这两个字符。如果不存在这样的子字符串，返回 -1 。

子字符串是字符串中的一个连续字符序列。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/largest-substring-between-two-equal-characters
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution(object):

def maxLengthBetweenEqualCharacters(self, s):

ans=-1

firstIndex={}

for i ,c in enumerate(s):

if c not in firstIndex:

firstIndex[c]=i

else:

ans=max(ans,i-firstIndex[c]-1)

return ans

class Solution:

对于该题总的enumerate()函数的使用方法：

list1 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list1):
print index, item
>>>
0 这
1 是
2 一个
3 测试
enumerate还可以接收第二个参数，用于指定索引起始值，如：
list1 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list1, 1):
print index, item
>>>
1 这
2 是
3 一个
4 测试

————————————————
版权声明：本文为CSDN博主「Childhood_Sweetheart」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/childhood_sweetheart/article/details/108281766

理解：
使用enumerate()函数将输入字符串中的单个字符进行编号，之后在定义一个字典，对编好号的字符串序列进行循环，将第一次出现的字符记录在字典中，将字典的值定义为之前排好序的字符的编号，就是该单个字符第一次出现在字符串中的位置，之后在不断地循环遍历下去，因为该题要找的最长的子字符串，所以我们使用max(ans,i-firstIndex[c]-1)来获取。

LeetCode 设计了一款新式键盘，正在测试其可用性。测试人员将会点击一系列键（总计 n 个），每次一个。

给你一个长度为 n 的字符串 keysPressed ，其中 keysPressed[i] 表示测试序列中第 i 个被按下的键。releaseTimes 是一个升序排列的列表，其中 releaseTimes[i] 表示松开第 i 个键的时间。字符串和数组的下标都从 0 开始。第 0 个键在时间为 0 时被按下，接下来每个键都恰好在前一个键松开时被按下。

测试人员想要找出按键持续时间最长的键。第 i 次按键的持续时间为 releaseTimes[i] - releaseTimes[i - 1] ，第 0 次按键的持续时间为 releaseTimes[0] 。

注意，测试期间，同一个键可以在不同时刻被多次按下，而每次的持续时间都可能不同。

请返回单次按键持续时间最长的键，如果有多个这样的键，则返回按字母顺序排列最大的那个键。

输入：releaseTimes = [9,29,49,50], keysPressed = "cbcd"
输出："c"
解释：按键顺序和持续时间如下：
按下 'c' ，持续时间 9（时间 0 按下，时间 9 松开）
按下 'b' ，持续时间 29 - 9 = 20（松开上一个键的时间 9 按下，时间 29 松开）
按下 'c' ，持续时间 49 - 29 = 20（松开上一个键的时间 29 按下，时间 49 松开）
按下 'd' ，持续时间 50 - 49 = 1（松开上一个键的时间 49 按下，时间 50 松开）
按键持续时间最长的键是 'b' 和 'c'（第二次按下时），持续时间都是 20
'c' 按字母顺序排列比 'b' 大，所以答案是 'c'
链接：https://leetcode.cn/problems/slowest-key
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution(object):

def slowestKey(self, releaseTimes, keysPressed):

ans=keysPressed[0]

maxtime=releaseTimes[0]

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

key=keysPressed[i]

time=releaseTimes[i]-releaseTimes[i-1]

if time>maxtime or time==maxtime and key>ans:

ans=key

maxtime=time

return ans

对于该题没有什么好讲的，主要是循环。