打卡Day23
- 1.39. 组合总和
- 2.40.组合总和II
- 3.131.分割回文串
1.39. 组合总和
题目链接：39. 组合总和
文档讲解： 代码随想录
这道题和昨天做的组合之和由两个区别：被选的元素没有数量限制，同时被选的元素可以无限重复，只对总和进行限制。那么终止条件可以定为，和大于等于目标。单层逻辑，和组合之和一样的思路，只是在递归中不用 i + 1。最后是输入参数：整数数组、目标和、startindex（因为在一个数组里选择，避免重复）、和（记录遍历元素之和）、结果列表、路径列表。
class Solution(object):
def combinationSum(self, candidates, target):
"""
:type candidates: List[int]
:type target: int
:rtype: List[List[int]]
"""
res = []
self.backtracking(candidates, target, 0, 0, res, [])
return res
def backtracking(self, candidates, target, startindex, summ, res, path):
#终止条件
if summ > target:
return
if summ == target:
res.append(path[:])
return
for i in range(startindex, len(candidates)):
path.append(candidates[i])
summ += candidates[i]
self.backtracking(candidates, target, i, summ, res, path)
summ -= candidates[i]
path.pop()
关于剪枝：如果加上本层递归的元素值，和已经大于目标值的情况，仍然会在进入下一层递归的时候才能判断和大于目标值，从而 return。因此，可以在本层判断是否加上本层元素值大于目标值来进行剪枝操作。一个非常重要的点就是，在进行递归前，需要将 candidates 数组进行排序。
class Solution(object):
def combinationSum(self, candidates, target):
"""
:type candidates: List[int]
:type target: int
:rtype: List[List[int]]
"""
res = []
candidates.sort()
self.backtracking(candidates, target, 0, 0, res, [])
return res
def backtracking(self, candidates, target, startindex, summ, res, path):
#终止条件
if summ == target:
res.append(path[:])
return
for i in range(startindex, len(candidates)):
#剪枝
if summ + candidates[i] > target:
break
path.append(candidates[i])
summ += candidates[i]
self.backtracking(candidates, target, i, summ, res, path)
summ -= candidates[i]
path.pop()
递归的第二个版本：与上一个版本的区别在于，不定义一个记录和的变量，使用 target 减去元素值，通过判断是否为0来终止递归。需要注意的是，终止条件包含两种情况：目标值为0，以及值小于0。
class Solution(object):
def combinationSum(self, candidates, target):
"""
:type candidates: List[int]
:type target: int
:rtype: List[List[int]]
"""
res = []
self.backtracking(candidates, target, 0, res, [])
return res
def backtracking(self, candidates, target, startindex, res, path):
if target == 0:
res.append(path[:])
return
if target < 0:
return
for i in range(startindex, len(candidates)):
path.append(candidates[i])
self.backtracking(candidates, target - candidates[i], i, res, path)
path.pop()
剪枝版本：就是在进行下一层递归前判断是否减去本层值小于0。依然是需要排序。
class Solution(object):
def combinationSum(self, candidates, target):
"""
:type candidates: List[int]
:type target: int
:rtype: List[List[int]]
"""
res = []
candidates.sort()
self.backtracking(candidates, target, 0, res, [])
return res
def backtracking(self, candidates, target, startindex, res, path):
if target == 0:
res.append(path[:])
return
for i in range(startindex, len(candidates)):
if target - candidates[i] < 0:
break
path.append(candidates[i])
self.backtracking(candidates, target - candidates[i], i, res, path)
path.pop()
2.40.组合总和II
题目链接：40.组合总和II
文档讲解： 代码随想录
我的思路：和上一题不同的是，每个数字在每个组合中只能使用一次，只能使用一次的两个意思，递归时开始指针变为 i + 1，同时需要考虑到整型数组里有重复元素。那在开始前先进行排序，使用双指针的方法，用 pre 指针记住当前遍历的前一个元素，若相同直接 break 该层循环，从而达到去重的效果。没做出来，发现我理解错题目意思了，元素在同一个组合内是可以重复的，怎么重复都没事，但两个组合不能相同。这是我昨天的思路，我今天想到，这个是数组，不用 pre 指针，它可以通过 i - 1的下标来取前一个元素。这种思路会将例如 [1,1,6] 的组会去掉。
题解：整型数组里有重复元素，例如[10,1,2,7,4,1,6]，目标值为8，第一个1和7组合，7和第二个1组合，这两个组合一样，需要去重。但第一个1，6，第二个1组合是允许的。因此，要去重的是同一树层上的相同元素，同一树枝上是一个组合里的元素，是可以重复的，因此不用去重。
class Solution(object):
def combinationSum2(self, candidates, target):
"""
:type candidates: List[int]
:type target: int
:rtype: List[List[int]]
"""
candidates.sort()
res = []
self.backtracking(candidates, target, res, [], 0)
return res
def backtracking(self, candidates, target, res, path, startindex):
#终止条件
if target == 0:
res.append(path[:])
return #结束函数
for i in range(startindex, len(candidates)):
#去重
if i > startindex and candidates[i] == candidates[i - 1]:
continue#结果该层for循环
if target - candidates[i] < 0:
break#结束for循环
path.append(candidates[i])
self.backtracking(candidates, target - candidates[i], res, path, i + 1)
path.pop()
class Solution(object):
def combinationSum2(self, candidates, target):
"""
:type candidates: List[int]
:type target: int
:rtype: List[List[int]]
"""
#使用used数组
candidates.sort()
uesd = [False] * len(candidates)
res = []
self.backtracking(candidates, target, uesd, res, [], 0)
return res
def backtracking(self, candidates, target, used, res, path, startindex):
if target == 0:
res.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 target - candidates[i] < 0:
break
path.append(candidates[i])
used[i] = True
self.backtracking(candidates, target - candidates[i], used, res, path, i + 1)
path.pop()
used[i] = False
3.131.分割回文串
题目链接：131.分割回文串
文档讲解： 代码随想录
这道题有如下几个难点:
（1）为什么切割问题可以抽象为组合问题
假设对于字符串abcde，切割问题思路是，先切割 a，再在bcde中切割第二段，切割 b 后，再切割第三段，这与组合的选取思路是类似的，因此可以抽象为组合问题
（2）如何模拟切割线
使用startindex表示切割线
（3）切割问题中递归如何终止
当遍历到字符串末尾时，则说明已经找到一种切割方法，每个叶子节点就是一种切割结果。因为本题中，切割出来的不是回文子串是不会向下递归的
（4）在递归循环中如何截取子串
从 startindex到 i 的范围就是切割出来的子串
（5）如何判断回文
使用双指针法，一个指针从前往后，一个指针从后往前，如果前后指针所指向的元素是相等的，则为回文子串
class Solution(object):
def partition(self, s):
"""
:type s: str
:rtype: List[List[str]]
"""
res = []
self.backtracking(s, 0, res, [])
return res
def backtracking(self, s, startindex, res, path):
#终止条件
if startindex == len(s):
res.append(path[:])
return
for i in range(startindex, len(s)):
#判断是否为回文
if self.ishuiwen(s, startindex, i):
#是回文
path.append(s[startindex:i + 1]) #左闭右开
self.backtracking(s, i + 1, res, path)
path.pop()
def ishuiwen(self, s, left, right):
#左闭右闭
while left <= right:
if s[left] != s[right]:
return False
left += 1
right -= 1
return True
这道题的优化都是在优化判断是否为回文子串上。
class Solution(object):
def partition(self, s):
"""
:type s: str
:rtype: List[List[str]]
"""
res = []
self.backtracking(s, 0, res, [])
return res
def backtracking(self, s, startindex, res, path):
if startindex == len(s):
res.append(path[:])
return
for i in range(startindex, len(s)):
#是否为回文
if s[startindex:i + 1] == s[startindex:i + 1][::-1]:
path.append(s[startindex:i + 1])
self.backtracking(s, i + 1, res, path)
path.pop()
具体来说，给定一个字符串 s，长度为 n，成为回文串的充分必要条件是 s[0] == s[n -1] 且 s[1:n - 1] 也是回文串，因此可以在回溯算法前，计算出 s 中所有子串是否为回文串，然后递归的时候直接查询就可以了。
class Solution(object):
def partition(self, s):
"""
:type s: str
:rtype: List[List[str]]
"""
hwjuzhen = [[False] * len(s) for i in range(len(s))]
self.huiwencom(s, hwjuzhen)
res = []
self.backtracking(s, 0, res, [], hwjuzhen)
return res
def backtracking(self, s, startindex, res, path, hwjuzhen):
if startindex == len(s):
res.append(path[:])
return
for i in range(startindex, len(s)):
if hwjuzhen[startindex][i]:
path.append(s[startindex:i + 1])
self.backtracking(s, i + 1, res, path, hwjuzhen)
path.pop()
def huiwencom(self, s, hwjuzhen):
for i in range(len(s) - 1, -1, -1):
for j in range(i, len(s)):
if i == j:
#单个字母必是回文串
hwjuzhen[i][j] = True
elif j - i == 1:
#两个字母判断是否相同
hwjuzhen[i][j] = (s[i] == s[j])
else:
hwjuzhen[i][j] = (s[i] == s[j] and hwjuzhen[i + 1][j - 1])
还可以使用python内置的 all 函数来判断是否回文。
class Solution(object):
def partition(self, s):
"""
:type s: str
:rtype: List[List[str]]
"""
res = []
self.backtracking(s, 0, res, [])
return res
def backtracking(self, s, startindex, res, path):
if startindex == len(s):
res.append(path[:])
return
for i in range(startindex, len(s)):
sub = s[startindex:i + 1]
if self.ishuiwen(sub):
path.append(s[startindex: i + 1])
self.backtracking(s,i + 1, res, path)
path.pop()
def ishuiwen(self, s):
return all(s[i] == s[len(s) - 1 -i] for i in range(len(s) // 2))
