Day 20 回溯 part02

LC 39. 组合总和

有思路，自己写了一遍，一顿操作猛如虎，一看击败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()

LC 40. 组合总和 II

本题涉及剪枝，不能先把所有的结果求出来后再去重，这样会超时。

关于去重，我是这么理解的：

我们允许同一个数字在一个树枝上多次使用，但是对于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)