给你一个 无重复元素 的整数数组 candidates
和一个目标整数 target
,找出 candidates
中可以使数字和为目标数 target
的 所有 不同组合 ,并以列表形式返回。你可以按 任意顺序 返回这些组合。
candidates
中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同,则两种组合是不同的。
对于给定的输入,保证和为 target
的不同组合数少于 150
个。
输入: candidates = [2,3,5] target = 8 输出: [[2,2,2,2],[2,3,3],[3,5]]
所给的数组里的数字是不重复发。
class Solution:
# 递归函数
def backtracking(self, total, result, startIndex, path, target, candidates):
# 终止条件
if total > target:
return
if total == target:
result.append(path[:])
return
# 遍历
for i in range(startIndex, len(candidates)):
total += candidates[i]
path.append(candidates[i])
# 调用递归
self.backtracking(total, result, i, path, target, candidates)
# 上面 是从i不是i+1的原因:每个数字可以重复使用
total -= candidates[i] # 弹出
path.pop() # 回溯
# 主函数
def combinationSum(self, candidates, target):
result = []
self.backtracking(0, result, 0, [], target, candidates)
return result
给定一个候选人编号的集合 candidates
和一个目标数 target
,找出 candidates
中所有可以使数字和为 target
的组合。
candidates
中的每个数字在每个组合中只能使用 一次 。
注意:解集不能包含重复的组合。
和上一题的区别:每个数字不能重复使用,但是列表里有重复的数字。
所以要去重,利用used数组判断,这是本题解答的核心。
class Solution:
def backtracking(self, candidates, target, total, startIndex, used, path, result):
if total == target:
result.append(path[:])
return
for i in range(startIndex, len(candidates)):
if i > startIndex and candidates[i] == candidates[i - 1] and not used[i - 1]: # 去重
continue
if total + candidates[i] > target:
break
total += candidates[i]
path.append(candidates[i])
used[i] = True # candidates[i]被使用过
self.backtracking(candidates, target, total, i + 1, used, path, result) # 继续搜索
used[i] = False # 没有被用过
total -= candidates[i]
path.pop()
def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
used = [False] * len(candidates) # 将used数组全部初始化为False,表示所有的元素都还没有被使用过
result = []
candidates.sort() # 给数组排序
self.backtracking(candidates, target, 0, 0, used, [], result)
return result
给你一个字符串 s
,请你将 s
分割成一些子串,使每个子串都是 回文串 。返回 s
所有可能的分割方案。
回文串 是正着读和反着读都一样的字符串。
示例 1:
输入:s = "aab" 输出:[["a","a","b"],["aa","b"]]
看过视频的思路
重要的是多了一步判断回文的函数,以及把startIndex作为切割线,以及每次收集结果的时候利用切片。
class Solution:
# 判断是不是回文串
def is_palindrome(self, s: str, start: int, end: int) -> bool:
i:int = start
j:int = end
while i < j:
if s[i] != s[j]:
return False
i += 1
j -= 1
return True
# 递归
def backtracking(self, s, path, result, startIndex):
# 终止条件
if startIndex == len(s):
result.append(path[:])
return
# 遍历 单层递归逻辑
for i in range(startIndex, len(s)):
if self.is_palindrome(s, startIndex, i): # 调用判断回文串的函数
path.append(s[startIndex:i + 1]) # 切片
self.backtracking(s, path, result,i + 1)
path.pop()
# 主函数
def partition(self, s: str):
result = []
self.backtracking(s, [], result,0)
return result