力扣回溯算法经典题-python实现

于 2022-07-11 23:20:32 发布
阅读量425 收藏 2
点赞数 2
分类专栏： python学习 文章标签： 算法 leetcode python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44714543/article/details/125730652
版权

文章目录

组合

77.组合

  • 题目：给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的不同组合。
class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        def dfs(n, k, path, res, start_index):
            if k == 0:  # 当k等于0时，说明一个组合已经找到，可以放到res中
                res.append(path[:])  # 注意path一定是深拷贝
                return
            for i in range(start_index, n+1):
                path.append(i)
                dfs(n, k-1, path, res, i+1)  # 下一次递归时，k个数变成了k-1个数。每个数字不能重复取，从i+1开始取
                path.pop()
        path, res = [], []
        start_index = 1
        dfs(n, k, path, res, start_index)
        return res
print(Solution().combine(n=4, k=2))

216.组合总和3

  • 题目：找出所有相加之和为 n 的 k 个数的不同组合。只使用数字1到9；每个数字最多使用一次。
class Solution:
    def combinationSum3(self, k: int, n: int) -> List[List[int]]:
    	def dfs(k, n, path, res, start_index):
    		if k == 0 and n == 0:  # 因为求得是组合总和，因此多了n==0的限制条件
    			res.append(copy.deepcopy(path))
    			return
    		for i in range(start_index, 10): # 相比组合，仅仅只是[1,n]，变成了[1,9]
    			path.append(i)
    			dfs(k-1, n-i, path, res, i+1)  # 每个数字不能重复取，从i+1开始取
    			path.pop()
    	path, res = [], []
    	start_index = 1
    	dfs(k, n, path, res, start_index)
    	return res
print(Solution().combinationSum3(k = 3, n = 7))

39.组合总和

  • 题目：给定一个无重复元素的数组nums和一个目标整数 target ，找出 nums中可以使数字和为 target 的所有不同组合。nums中的同一个数字可以无限制重复被选取 。
    输入：nums = [2,3,6,7], target = 7
    输出：[[2,2,3],[7]]
class Solution:
    def combinnationSum(self, nums: List[int], target: int) -> List[List[int]]:
    	def dfs(nums, path, res, start_index, target):
    		if target == 0:
    			res.append(copy.deepcopy(path))
    			return
    		for i in range(start_index, len(nums)):
    			if nums[i] <= target:  # 判断候选数组里面的数，只有比target小才有意义。
    				path.append(nums[i])
    				dfs(nums, path, res, i, target-nums[i])  # 这里从i开始取，是因为同一个数字可以重复被选择
    				path.pop()
    	path, res = [], []
    	start_index = 0  # 数组下标从0开始
    	dfs(nums,path,res,start_index,target)    			
      	return res

print(Solution().combinnationSum(nums=[2, 3, 6, 7], target=7))

40.组合总和2

  • 题目：给定一个整数数组 nums和一个目标数 target ，找出 nums中可以使数字和为 target 的所有不同组合。nums中的每个数字在每个组合中只能使用一次 。
    输入: nums= [2,5,2,1,2], target = 5,
    输出: [[1,2,2],[5]]
class Solution:
    def combinationSum2(self, nums: List[int], target: int) -> List[List[int]]:
    	nums.sort()  # 先排序，再剪枝，剪掉以相同数字为主的组合。
	    def dfs(nums, path, res, start_index, target):
	   		if target == 0:
	   			res.append(copy.deepcopy(path))
	   			return
	   		for i in range(start_index, len(nums)):
	   		# 经典剪枝操作，排序后，后面相等的数就不必再进行搜索了。i>start_index是为了保证nums[i-1]有意义
	   			if i > start_index and nums[i] == nums[i-1]: 
	   				continue
	   			if nums[i] <= target:
	   				path.append(nums[i])
	   				dfs(nums, path, res, i+1, target-nums[i]) # 因为每个数不能重复取，因此下一次递归从i+1开始
	   				path.pop()
	   	path, res = [], []
	   	start_index = 0
	   	dfs(nums,path,res,start_index,target)    			
	    return res

print(Solution().combinationSum2(nums=[10,1,2,7,6,1,5], target=8))

子集

78.子集

  • 题目：给你一个无重复元素整数数组 nums ，返回该数组所有可能的不同子集。
class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
      	def dfs(nums, path, res, start_index):
      		res.append(copy.deepcopy(path))
      		for i in range(start_index, len(nums)):
      			path.append(nums[i])
      			dfs(nums, path, res, i+1)  # 每个数字不能重复取
      			path.pop()
      	path, res = [],[]
      	start_index = 0
      	dfs(nums, path, res, start_index)
      	return res
      	   
print(Solution().subsets(nums = [1,2,3]))

90.子集2（不剪枝）

  • 题目：给你一个可能包含重复元素整数数组 nums ，请你返回该数组所有可能的不同子集。
class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
    	nums.sort()  # 排序至关重要，只有排序了，才能消除相同的子集
      	def dfs(nums, path, res, start_index):
      		if path not in res:
      			res.append(copy.deepcopy(path))
      			return 
      		for i in range(start_index, len(nums)):
      			path.append(nums[i])
      			dfs(nums, path, res, i+1)   # 每个数字可以相同，但不能重复取同一个元素。
      			path.pop()
      	path, res = [],[]
      	start_index = 0
      	dfs(nums, path, res, start_index)
      	return res
      	     	
print(Solution().subsets(nums = [1,2,3]))

90.子集2（剪枝）

class Solution:
	nums.sort()  # 排序不可少
    def subsets(self, nums: List[int]) -> List[List[int]]:
      	def dfs(nums, path, res, start_index):
      		res.append(copy.deepcopy(path))
      		for i in range(start_index, len(nums)):
      			# 经典剪枝
      			if i > start_index and nums[i] == nums [i-1]:  
      				continue
      			path.append(nums[i])
      			dfs(nums, path, res, i+1)
      			path.pop()
      	path, res = [],[]
      	start_index = 0
      	dfs(nums, path, res, start_index)
      	return res
      	     	
print(Solution().subsets(nums = [1,2,3]))

全排列

46.全排列

  • 题目：给定一个不含重复数字的数组 nums ，返回其所有可能的不重复的全排列 。
class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
    	visited = [False for _ in range(len(nums))]
    	def dfs(nums, path, res, visited, depth):
    		if depth == len(nums):
    			res.append(copy.deepcopy(path))
    			return 
    		for i in range(len(nums)):
    			if not visited[i]:
	    			visited[i] = True
	    			path.append(nums[i])
	    			dfs(nums, path, res, visited, depth+1)
	    			visited[i] = False
	    			path.pop()
    	path, res = [], []
    	depth = 0
    	dfs(nums, path, res, visited, depth)
    	return res
    		
print(Solution().permute(nums=[1,2]))

47.全排列2（不剪枝）

  • 题目：给定一个可包含重复数字的序列 nums ，按任意顺序返回所有不重复的全排列。
class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
    	visited = [False for _ in range(len(nums))]
    	def dfs(nums, path, res, visited, depth):
    		if depth == len(nums):
    			if path not in res:
	    			res.append(copy.deepcopy(path))
	    			return 
    		for i in range(len(nums)):
    			if not visited[i]:
	    			visited[i] = True
	    			path.append(nums[i])
	    			dfs(nums, path, res, visited, depth+1)
	    			visited[i] = False
	    			path.pop()
    	path, res = [], []
    	depth = 0
    	dfs(nums, path, res, visited, depth)
    	return res
    		
print(Solution().permute(nums=[1,2]))

47.全排列2（剪枝）

  • 题目：给定一个可包含重复数字的序列 nums ，按任意顺序返回所有不重复的全排列。
class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
    	nums.sort()
    	visited = [False for _ in range(len(nums))]
    	def dfs(nums, path, res, visited, depth):
    		if depth == len(nums):
    			res.append(copy.deepcopy(path))
    			return 
    		for i in range(len(nums)):
    			if i > 0 and nums[i] == nums[i-1] and not visited[i-1]:
    				continue
    			if not visited[i]:
	    			visited[i] = True
	    			path.append(nums[i])
	    			dfs(nums, path, res, visited, depth+1)
	    			visited[i] = False
	    			path.pop()
    	path, res = [], []
    	depth = 0
    	dfs(nums, path, res, visited, depth)
    	return res
    		
print(Solution().permute(nums=[1,2]))

总结：

  1. 数组中的元素是否重复
  • 是：要考虑相同元素为首的重复集合（排序，剪枝）
  • 否：不用剪枝
  1. 数组中的元素是否可以重复使用
  • 是：下一次dfs从i开始
  • 否：下一次dfs从i+1开始
夏赞恩
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python算法题源代码-LeetCode(力扣)-单词搜索
03-03
力扣热题Python源代码 题目79. 单词搜索 给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。 单词必须按照字母顺序，通过相邻的单元格内的字母...
Python算法题源代码-LeetCode(力扣)-分割回文串
最新发布
03-05
力扣热题Python源代码 题目131. 分割回文串 给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。 回文串 是正着读和反着读都一样的字符串。 示例 1： 输入：s = ...
力扣----经典题（python实现）
一夜奈何梁山
03-11 2737
经典题一：两数之和：二：三数之和：三：两数相加：四： 买股票的最佳时机： 一：两数之和： 二：三数之和： 1：首先我们要对数组进行排序， 排序的原因是因为不允许出现重复的。 2：第一层循环，我们可以循环遍历数组，枚举a，而且我们要判断当前枚举的和上次枚举的是否值是相同的，如果相同的，则直接跳过。 3：第二层中，我们可以计算出，剩余两个相加需要的和。我们可以让第三个指针，指向末尾，然后循环遍历第二个指针， 4：第三层中，每次第二个指针到达一个位置，我们计算这两个指针的相加和是多少，如果大于需要的和，说明加多
python——力扣题
weixin_63414347的博客
04-24 171
python数字组合算法_组合总和—回溯算法经典例题
weixin_39911475的博客
11-23 433
给定一个无重复元素的数组 nums 和一个目标数 sum，输出所有使数字和为目标数的组合。输入：nums=[3,5,2,6],sum=9输出：[[2,2,2,3],[2,2,5],[3,3,3],[3,6]]解题思路如下：将 nums 进行降序排序，令 nums=[6,5,3,2]。这样，如果和已经大于 9 就不需要再考虑后面的数字了。例如，6+5>9，所以我们可以直接排除 [6,5,3],[6,...
LeetCode：2两数相加
cxcf_wsy的博客
06-18 186
力扣算法：2两数相加
面试刷题必会：回溯法详解（python代码模板，学会了秒杀回溯题）
weixin_44414948的博客
03-07 1137
回溯法 「回溯法」实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就「回溯」返回，尝试别的路径。 回溯法是一种算法思想，而递归是一种编程方法，回溯法可以用递归来实现。 回溯法的整体思路是：搜索每一条路，每次回溯是对具体的一条路径而言的。对当前搜索路径下的的未探索区域进行搜索，则可能有两种情况： 当前未搜索区域满足结束条件，则保存当前路径并退出当前搜索； 当前未搜索区域需要继续搜索，则遍历当前所有可能的选择：如果该选择符合要求，则把当前选择加入当前的搜索路径
Python算法题源代码-LeetCode(力扣)-组合总和
02-29
力扣热题Python源代码 39. 组合总和 给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ， 并以列表形式返回。你可以按 任意...
Python算法题源代码-LeetCode(力扣)-括号生成
03-02
力扣热题Python源代码 题目22. 括号生成 数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。 示例 1： 输入：n = 3 输出：["((()))","(()())","(())()","()(())","()()...
LeetCode 刷题攻略：配思维导图，100+经典算法题目刷题顺序、经典算法模板-Python开发
05-25
回溯算法之组合问题（力扣题目：77.组合） 组合问题的剪枝操作（对应力扣题目：77.组合） 组合总和（对应力扣题目：39.组合总和） （持续更新中....） LeetCode 刷题攻略 刷题攻略的背景 很多刚开始刷题的...
回溯法经典例题——python
qq_49425744的博客
04-06 972
1。七段码 2.年串字号 3.正整数分解 4.回路计数 5.N皇后问题
力扣-算法练习(Python)
yt_xy的博客
07-01 381
1.两数之和 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。 示例： 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以 返回 [0, 1] 思路：A+B=target => target-A=B 第一次尝试 class Solution(object
Python3 ----力扣算法题(持续更新）
qq_29617883的博客
09-25 477
一、几数之和系列问题 1.两数之和 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回...
【力扣每日一题】每日一题Python代码详解【持续更新】
QAQjiaru233的博客
12-07 743
861.翻转后矩阵的得分（12.7日） 代码详解如下： class Solution(object): def matrixScore(self, A): """ :type A: List[List[int]] :rtype: int """ m = len(A) #行数 n = len(A[0]) #列数 # 第一步，先将二维列表第一列数值不是1的行进行行变化，将第
力扣 week1（Python题解）
momo的博客
05-09 574
不知道现在刷题还来不来得及，看到有人说一个月认真刷就行，所以就想试试，万一呢 准备从今天开始，按顺序认真刷题并记录过程中的一些小点 python列表操作： nums.remove(3) “3”表示数值，并且只能删除nums中第一个3 nums.pop(3) "3"表示索引，pop表示删除nums中第四个位置上的数据（python序列索引从0开始） nums.index(3) nums.sort() index表示数值“3”在num...
python3 力扣 刷题 随笔
m0_52785249的博客
10-15 131
动态规划 .join()函数：一个字符串方法，它返回被子字符串连接的字符串。 语法： ‘sep’.join(seq) 参数说明 sep： 分隔符。可以为空 seq： 要连接的元素序列、字符串、元组、字典 上面的语法即： 以sep作为分隔符，将seq所有的元素合并成一个新的字符串 返回值： 返回一个以分隔符sep连接各个元素后生成的字符串 参数： The join() method takes join()方法需要可迭代的元素来一次返回它的一个成员，比如列表，元组，字符串，字典和集合 返回值： join.
力扣 算法面试题汇总 Python
荷碧TongZJ 的水文
02-08 3529
近期在刷力扣官网的这份题，因为我是因为报名了蓝桥杯才刷算法题的，所以我会选择性地写一些题解 (不包括太简单的、太难的、不在我考试范围的) 以下都是我觉得比较有思考价值的题 热身： 1. 只出现一次的数字 读题之后可以找到两个重点：只有一个元素只出现了一次、其余每个元素均出现两次 “相同为0，相异为1”，马上想到异或运算。所有元素都异或在一起，最终的数值就是只出现一次的元素 class Solution(object): def singleNumber(self, n.
Python-力扣 面试题 17.14. 最小K个数
害怕也得前进
10-06 325
力扣 面试题 17.14. 最小K个数
力扣算法题总结（python）—双指针
白羊by的博客
03-16 1430
双指针-移除元素： 双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。 双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组、链表、字符串等操作的面试题，都使用双指针法。 双指针力扣相关题目 27.移除元素 26.删除有序数组中的重复项 283.移动零 844.比较含退格的字符串 原因分析： 提示：这里填写问题的分析： 例如：Handler 发送消息有两种方式，分别是 Handler.obtainMessage()和 Handler.send
力扣 回溯算法 java
10-18
以下是一个力扣题目的回溯算法 Java 实现示例： ``` class Solution { List<List<Integer>> res = new ArrayList(); List<Integer> path = new ArrayList(); public List<List<Integer>> subsets(int[] nums) {...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值