今天知道了一个很难过的事情,但是还是要好好工作好好生活呀,继续努力规律的过好每一天。
今天的每日一题超级简单没什么好说的,那我们就来复习昨天的回溯法,以及做一些之前的题目,然后这周复习一下机器学习知识点,加油呀冉冉。
46. 全排列
给定一个不含重复数字的数组 nums ,返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
题目描述
示例 1:
输入:nums = [1,2,3]
输出:[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
示例 2:
输入:nums = [0,1]
输出:[[0,1],[1,0]]
示例 3:
输入:nums = [1]
输出:[[1]]
提示:
- 1 <= nums.length <= 6
- -10 <= nums[i] <= 10
- nums 中的所有整数 互不相同
思路
用时: 10:41-10:53
回溯法模版
思考3个东西:
- 路径
- 可选择集合
- 结束标志
result = []
def backtrack(路径,可选择集合):
if 结束:
result.add(路径)
return
for 选择 in 可选择集合:
做选择
backtrack(路径,选择列表)
撤销选择
写出来了但是感觉不对:
class Solution:
def permute(self, nums: List[int]) -> List[List[int]]:
result = []
def backtrack(path,selections):
if not selections:
result.append(path)
for ind,select in enumerate(selections):
new_path = path+[select]
if len(selections)>1:
backtrack(new_path,selections[:ind]+selections[ind+1:])
else:
backtrack(new_path,[])
backtrack([],nums)
return result
这种写法的问题:
- 递归函数的内存问题,每个递归函数切割并且向下传递了一个nums,空间复杂度约等于递归深度*O(n)
- 每个递归函数里面都又了切片:nums[:i]+nums[i+1:],时间复杂度时O(n)切片的时间复杂度大小等于切片数组的大小,时间复杂度又扩大了n倍。
⇒ 递归函数眼科控制传入的parameter: 1、不是常数级别的参数 2. 传入饮用但是后续递归中拷贝。
先抄一下官方题解找找感觉:
class Solution:
def permute(self,nums):
def batcktrack(first):
if first==n:
res.append(nums[:])
for i in range(first,n):
# 选择一个数
nums[first],nums[i]= nums[i],nums[first]
# 继续递归填下一个数
bactrack(first+1)
# 撤销操作
nums[first],nums[i] = nums[i],nums[first]
n = len(nums)
res = []
backtrack(0)
return res
真的非常巧妙啊,
而且题解虽然定义了 index 和output两个参数,实际实现的时候并没有output。
- 时间复杂度: O(nxn!),其中n为序列的长度。递归的时间复杂度是 n ! n! n!,并且需要o(n)的时间复制数组
- 空间复杂度:O(n), 除了答案数组,递归函数在递归过程中需要为每一层递归函数分配栈空间,额外空间取决于递归的深度,递归深度为O(n).
继续下一道回溯题。
22.括号生成
https://leetcode-cn.com/problems/generate-parentheses/
题目描述
数字 n 代表生成括号的对数,请你设计一个函数,用于能够生成所有可能的并且 有效的 括号组合。
有效括号组合需满足:左括号必须以正确的顺序闭合。
示例 1:
输入:n = 3
输出:["((()))","(()())","(())()","()(())","()()()"]
示例 2:
输入:n = 1
输出:["()"]
提示:
- 1 <= n <= 8
思考
回溯解法
其实合法的要求也很简单,左括号的数量一直大于等于右括号就行。
所以如果我写的法,传三个参数
ind,left_num,right_num
来吧展示,
class Solution:
def generateParenthesis(self, n: int) -> List[str]:
res = []
tmp = [None for i in range(n*2)]
def backtrack(index,left_num,right_num):
if index == 2*n:
res.append("".join(tmp))
return
# 根据index 和 left_num 生成不同的
for char in ["(",")"]:
if char == "(":
if left_num < n:
tmp[index] = char
backtrack(index+1,left_num+1,right_num)
else:
if right_num<left_num:
tmp[index] = char
backtrack(index+1,left_num,right_num+1)
backtrack(0,0,0)
return res
核心就是什么合法才遍历选择什么。
在做最后一题,就去睡觉
17. 电话号码的字母组合
https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number/
题目描述
给定一个仅包含数字 2-9 的字符串,返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
给出数字到字母的映射如下(与电话按键相同)。注意 1 不对应任何字母。
示例 1:
输入:digits = "23"
输出:["ad","ae","af","bd","be","bf","cd","ce","cf"]
示例 2:
输入:digits = ""
输出:[]
示例 3:
输入:digits = "2"
输出:["a","b","c"]
提示:
- 0 <= digits.length <= 4
- digits[i] 是范围 [‘2’, ‘9’] 的一个数字。
思路
之前的解法: 暴力+ 递归
class Solution:
def letterCombinations(self, digits: str):
#方法:暴力映射+递归
num_dict = {'2':['a','b','c'],'3':list('def'),
'4':list('ghi'),'5':list('jkl'),'6':list('mno'),
'7':list('pqrs'),'8':list('tuv'),'9':list('wxyz')}
if len(digits) == 0 or '1' in digits:
return []
if len(digits) == 1:
return num_dict[digits[-1]]
else:
return [str_+char for str_ in self.letterCombinations(digits[:-1]) for char in num_dict[digits[-1]]]
回溯法优化
用时:11:55-11:59
class Solution:
def letterCombinations(self, digits: str):
if not digits: return []
num_dict = {'2':['a','b','c'],'3':list('def'),
'4':list('ghi'),'5':list('jkl'),'6':list('mno'),
'7':list('pqrs'),'8':list('tuv'),'9':list('wxyz')}
n = len(digits)
res = []
path = [None for dig in digits]
def backtrack(ind):
if ind == n:
res.append("".join(path))
return
for char in num_dict[digits[ind]]:
path[ind] = char
backtrack(ind+1)
# 长度为0,1的测试
backtrack(0)
return res
我好像掌握了python回溯的秘诀,根本不用删除选择, 因为下一次会直接覆盖。
时间复杂度:
O
(
3
m
∗
4
n
)
O(3^m*4^n)
O(3m∗4n),其中m为对应3个字母的数字,n队赢个字母的数字。
空间复杂度:哈希表的大小,和回溯的递归层数。
今天回溯题很顺利,明天早起复习之前的题目吧,世界晚安。
感觉最近精神不好,总是头疼。