1.有效的括号
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。
示例 1：
输入：s = "()"
输出：true
示例 2：
输入：s = "()[]{}"
输出：true
示例 3：
输入：s = "(]"
输出：false
示例 4：
输入：s = "([])"
输出：true
方法一：我的方法，遇见就删库
py
class Solution:
def isValid(self, s: str) -> bool:
stack=[]
n=len(s)
if len(s)%2!=0:
return False
for i in range(n):
if s[i] in ('(', '[', '{'):
stack.append(s[i])
elif s[i] in (')', ']', '}'):
if not stack:
return False
elif s[i]==')' and stack[-1]=='(':
stack.pop()
elif s[i]==']' and stack[-1]=='[':
stack.pop()
elif s[i]=='}' and stack[-1]=='{':
stack.pop()
else:
return False
if not stack:
return True
else:
return False 方法二：字典：
py
class Solution:
def isValid(self,s:str)->bool:
if len(s)%2==1:
return False
pairs={
')':'(',
']':'[',
'}':'{'
}
stack=list()
for ch in s:
if ch in pairs:
if not stack or stack[-1] !=pairs[ch]:
return False
stack.pop()
else:
stack.append(ch)
return not stack这个代码的的逻辑很明显比我的要好，逻辑非常的清晰，我的逻辑包络了所有的可能性，但是不够合理，他的逻辑是使用字典，配对的理念确实很好。
2.合并两个有序数组
这个题很简单，主要是这里有一个要求
py
class Solution:
def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
"""
Do not return anything, modify nums1 in-place instead.
"""
res=[]
index1,index2=0,0
while index1<m and index2<n:
if nums1[index1]<=nums2[index2]:
res.append(nums1[index1])
index1+=1
else:
res.append(nums2[index2])
index2+=1
res+=nums1[index1:m] if index2==n else nums2[index2:n]
nums1[:m+n]=res他说do not return anything, 要求修改nums1。但是他的测试用例其实是在背后直接读原地址的，所以还是要修改原数列。nums1[:m+n]=res就可以了。
3.三数之和
py
class Solution:
def threeSum(self, nums: List[int]) -> List[List[int]]:
nums.sort()
res=[]
for first in range(len(nums)-2):
if first>0 and nums[first]==nums[first-1]:
continue
third=len(nums)-1
second=first+1
while third>second:
if second>first+1 and nums[second]==nums[second-1]:
second+=1
continue
if third<len(nums)-1 and nums[third]==nums[third+1]:
third-=1
continue
ans=nums[first]+nums[second]+nums[third]
if ans==0:
res.append([nums[first],nums[second],nums[third]])
third-=1
elif ans>0:
third-=1
else: #ans<0:
second+=1
return res技术要点：
1.要对first进行限制，如果遇到同样的数字，那么就跳过
2.third为最后一个数字，second为first之后第一个数字
3.循环条件是second要小于third，对ans进行判断，如果小于，那就second放大，如果大于，那就third调小，如果相等，那就记录并且第三个降一个，也可以third和second同时降，这样的用时反而会更少。
4.括号生成
数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
示例 1：
输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]
示例 2：
输入：n = 1
输出：["()"]
py
from typing import List
class Solution:
def generateParenthesis(self, n: int) -> List[str]:
def dfs(ans,remaining):
if len(ans)==n*2:
if check(ans):
if ans not in res:
res.append(ans)
ans=''
return
else:return
else: return
for i in range(len(remaining)):
dfs(ans+remaining[i],remaining[:i]+remaining[i+1:])
def check(s:str)->bool:
stack=[]
for i in range(len(s)):
if not stack:
stack.append(s[0])
continue
if stack[-1]==')':
return False
else:
if s[i]==')':
stack.pop()
if s[i]=='(':
stack.append('(')
return not stack
res=[]
dfs('','()'*n)
return res我自己的办法，有太多太多的无用功了，超时
方法二：回溯算法：
py
class Solution:
def generateParenthesis(self,n:int)->List[str]:
res=[]
S=''
def backtrack(S,left,right):
if len(S)==2*n:
res.append(''.join(S))
return
if left<n:
S.append('(')
backtrack(S,left+1,right)
S.pop()
if right<left:
S.append(')')
backtrack(S,left,right+1)
S.pop()
backtrack([],0,0)
return res