8月17日--回溯法复习

今天知道了一个很难过的事情，但是还是要好好工作好好生活呀，继续努力规律的过好每一天。
今天的每日一题超级简单没什么好说的，那我们就来复习昨天的回溯法，以及做一些之前的题目，然后这周复习一下机器学习知识点，加油呀冉冉。

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 

这种写法的问题：

1. 递归函数的内存问题，每个递归函数切割并且向下传递了一个nums，空间复杂度约等于递归深度*O(n)
2. 每个递归函数里面都又了切片：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!$,并且需要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\ast 4^n)$,其中m为对应3个字母的数字，n队赢个字母的数字。
空间复杂度：哈希表的大小，和回溯的递归层数。

今天回溯题很顺利，明天早起复习之前的题目吧，世界晚安。
感觉最近精神不好，总是头疼。