【代码随想录|第七章回溯算法part02 |39.组合总和，40.组合总和II ，131.分割回文串】

---

python

一、39.组合总和

39.组合总和

1.核心代码

回溯的结构还不是很清楚，思路是有了的

class Solution:
    def combinationSum(self,candidates,target):
        result=[]
        self.backtracing(candidates,[], 0, target,result, 0)
        return result

    def backtracing(self,candidates,stack, sum, target,result, startIndex):
        if sum > target:
            return

        if sum == target:
            result.append(stack[:])
            return

        for i in range(startIndex,len(candidates)):
            stack.append(candidates[i])
            sum = sum + candidates[i]
            self.backtracing(candidates,stack, sum, target,result, i)
            sum = sum - candidates[i]
            stack.pop()

2.输入输出

毫无问题

class Solution:
    def combinationSum(self,candidates,target):
        result=[]
        self.backtracing(candidates,[], 0, target,result, 0)
        return result

    def backtracing(self,candidates,stack, sum, target,result, startIndex):
        if sum > target:
            return

        if sum == target:
            result.append(stack[:])
            return

        for i in range(startIndex,len(candidates)):
            stack.append(candidates[i])
            sum = sum + candidates[i]
            self.backtracing(candidates,stack, sum, target,result, i)
            sum = sum - candidates[i]
            stack.pop()


if __name__=="__main__":
    candidates=list(map(int,input().strip("[]").split(",")))
    target=int(input())
    solution=Solution()
    result=solution.combinationSum(candidates,target)
    print(result)

二、40.组合总和II

40.组合总和II

1.核心代码

难点是去重，
1、一个组合里面可以有重复的元素
2、所有组合里面不可以有重复的组合 （去重）

把问题转化为：
1、首先把原始集合里的元素去重
2、然后再用去重的元素，做可重复元素的组合（就解决了会出现两组一样元素的组合的情况了）

class Solution:
    def combinationSum(self,candidates,target):
        candidates.sort()
        result=[]
        self.backtracing(candidates,[], 0, target,result, 0)
        return result

    def backtracing(self,candidates,stack, sum, target,result, startIndex):
        if sum > target:
            return

        if sum == target:
            result.append(stack[:])
            return

        for i in range(startIndex,len(candidates)):
            if i>startIndex and candidates[i]==candidates[i-1]: #一个组合中可以出现相同的元素，但是不同组合中不可以，所以完全省略该重复情况
                continue
            stack.append(candidates[i])
            sum = sum + candidates[i]
            self.backtracing(candidates,stack, sum, target,result, i+1)
            sum = sum - candidates[i]
            stack.pop()

if i>startIndex and candidates[i]==candidates[i-1]:
一个组合中可以出现相同的元素，但是不同组合中不可以，所以完全省略该重复情况

2.输入输出

毫无问题

class Solution:
    def combinationSum(self,candidates,target):
        candidates.sort()
        result=[]
        self.backtracing(candidates,[], 0, target,result, 0)
        return result

    def backtracing(self,candidates,stack, sum, target,result, startIndex):
        if sum > target:
            return

        if sum == target:
            result.append(stack[:])
            return

        for i in range(startIndex,len(candidates)):
            if i>startIndex and candidates[i]==candidates[i-1]: #一个组合中可以出现相同的元素，但是不同组合中不可以，所以完全省略该重复情况
                continue
            stack.append(candidates[i])
            sum = sum + candidates[i]
            self.backtracing(candidates,stack, sum, target,result, i+1)
            sum = sum - candidates[i]
            stack.pop()


if __name__=="__main__":
    candidates=list(map(int,input().strip("[]").split(",")))
    target=int(input())
    solution=Solution()
    result=solution.combinationSum(candidates,target)
    print(result)

三、131.分割回文串

131.分割回文串
很难，因为纵向和横向的索引都需要控制，所以我优点迷茫了

1.核心代码

难点：

1、因为一个组合里的一个子串需要两个索引，起始和终止位置，所以需要搞清楚横向和纵向的索引的变化，并且这个子串就是由两个索引构成的。（思路上面）

2、代码方面：注意[]是左闭右开，注意取一段子串索引之间用: 注意self函数前面有了那么参数里面就不要

class Solution:
    def partition(self,s):
        result = []
        self.backtracing(s,0,[],result)
        return result

    def backtracing(self,s,start_index,path,result):
        if start_index == len(s):
            result.append(path[:])
            return

        for i in range(start_index,len(s)):
            if s[start_index:i+1] == s[start_index:i+1][::-1]:
                path.append(s[start_index:i+1])
                self.backtracing(s,i+1,path,result)
                path.pop()

if i>startIndex and candidates[i]==candidates[i-1]:
一个组合中可以出现相同的元素，但是不同组合中不可以，所以完全省略该重复情况

2.输入输出

毫无问题

class Solution:
    def partition(self,s):
        result = []
        self.backtracing(s,0,[],result)
        return result

    def backtracing(self,s,start_index,path,result):
        if start_index == len(s):
            result.append(path[:])
            return

        for i in range(start_index,len(s)):
            if s[start_index:i+1] == s[start_index:i+1][::-1]:
                path.append(s[start_index:i+1])
                self.backtracing(s,i+1,path,result)
                path.pop()

if __name__=="__main__":
    s=input()
    solution=Solution()
    result=solution.partition(s)
    print(result)

总结

输入输出