有思路,自己写了一遍,一顿操作猛如虎,一看击败5%,去重花了大量时间。
class Solution:
def backTrack(self, candidates , target):
if sum(self.path) == target:
self.res.append(self.path[:])
return
if sum(self.path) > target:
return None
for i in range(len(candidates)):
self.path.append(candidates[i])
self.backTrack(candidates , target)
self.path.pop()
return self.res
def remove_duplicates(self,ls):
unique_lists = []
seen = set()
for sublist in ls:
freq = {}
for num in sublist:
if num in freq:
freq[num] += 1
else:
freq[num] = 1
freq_tuple = tuple(sorted(freq.items()))
if freq_tuple not in seen:
seen.add(freq_tuple)
unique_lists.append(sublist)
return unique_lists
def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
self.path = []
self.res = []
return self.remove_duplicates(self.backTrack(candidates , target))
再看网站上的写法,豁然开朗,因为是组合,所以对[2,3,4]来说,取2,后续是在数组[2,3,4]中继续取;取3时,后续必须是在数组[3,4]继续取,否则会出现[2,3] , [3,2]这种重复的情况。
所以还是需要使用index控制当前取得是哪个数,改进后,代码如下:
class Solution:
def back_track(self , candidates , target , index = 0):
if sum(self.path) == target:
self.res.append(self.path[:])
return
if sum(self.path) > target:
return
for i in range(index , len(candidates)):
self.path.append(candidates[i])
self.back_track(candidates , target , i)
self.path.pop()
return self.res
def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
self.path = []
self.res = []
return self.back_track(candidates , target)
发现还是只击败了10%的选手,应该是没做剪枝操作的缘故。其实在for循环中,我们可以判断一下当前path数组的值是否大于target,如果是,则跳过本次循环。即:将下面两句话加到for循环后面
if candidates[i] + sum(self.path[:]) > target:
continue
再进一步,可以先排序,再进行操作。若不排序,continue为了避免漏解,还是要向后遍历,只能跳过本次。排序后若发现大于target,可以把后面的递归遍历全部扔掉。
这里复制粘贴如下:
class Solution:
def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
result =[]
candidates.sort()
self.backtracking(candidates, target, 0, [], result)
return result
def backtracking(self, candidates, target, startIndex, path, result):
if target == 0:
result.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, path, result)
path.pop()
本题涉及剪枝,不能先把所有的结果求出来后再去重,这样会超时。
关于去重,我是这么理解的:
我们允许同一个数字在一个树枝上多次使用,但是对于candidates数组中的每一个数字,我们不允许相同的数字重复的作为根节点。used数组实际上记录的是,遍历到哪个数字作为根节点了。
比如一个例子:candidates[1,1*,1^,2] ,上角标用以区别不同位置上的1, target = 3 ,.一开始used = [0,0,0] ,遍历到第一个1 时,将usd设置为 [1,0,0],继续递归调用 ,会收集到1*和1^,这是允许的,因为此时,第一个1作为根节点,同一个树枝上允许出现重复的1 。但是随着for循环继续,遍历到1*了,used[i-1] = 0 , 说明不属于第一个1的树枝,而是要把第二个1拿去做根节点了,这是不允许的!
因为若允许,将会收集到[1* , 2]这个结果,与之前的[1,2]重复 。
这就是去重的逻辑:同一个数字,只能当一次根节点。
class Solution:
def back_track(self, candidates , target , start_index , used):
if sum(self.path) == target:
self.res.append(self.path[:])
return
if sum(self.path) > target:
return
for i in range(start_index , len(candidates)):
if i > start_index and
candidates[i-1] == candidates[i] and self.used[i-1] == 0:
continue
if sum(self.path) + candidates[i] > target:
break
self.path.append(candidates[i])
self.used[i] = 1
self.back_track(candidates , target , i+1 , used)
self.path.pop()
self.used[i] = 0
return self.res
def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
self.path = []
self.res = []
self.used = [0] * len(candidates)
candidates.sort() #必须先排序,便于去重
return self.back_track(candidates , target , 0 , self.used)
LC 131 分割回文串
第一次接触分割类型的题,对于如何表示分割的子串还是有点模糊,需要进一步理解。
只要知道当前截取的子串是如何表示的,后续都好做了。
class Solution:
def back(self,s,index = 0):
if index == len(s):
self.res.append(self.path[:])
return
for i in range(index , len(s)):
if self.func(s , index , i) == True:
self.path.append(s[index : i+1])
self.back(s , i + 1)
self.path.pop()
return self.res
def func(self , s , start , end):
i , j = start , end
while i < j:
if s[i] != s[j]:
return False
i += 1
j -= 1
return True
def partition(self, s: str) -> List[List[str]]:
self.path = []
self.res = []
return self.back(s)