代码随想录day 27 39. 组合总和● 40.组合总和II● 131.分割回文串

class Solution(object):
    def combinationSum(self, candidates, target):
        """
        :type candidates: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        res=[]
        def dfs(candidates,begin,target,sum,cur,res):
            if sum > target:
                return
            if sum==target:
                res.append(cur[:])
                return
            for i in range(begin,len(candidates)):
                cur.append(candidates[i])
                begin = i
                dfs(candidates,begin,target,sum+candidates[i],cur,res)
                cur.pop()
        dfs(candidates,0,target,0,[],res)
        return res

每个数可以重复选，所以递归下次从上次的下标开始

class Solution(object):
    def combinationSum2(self, candidates, target):
        """
        :type candidates: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        res = []
        candidates.sort()
        def dfs(candidates,target,cur,start):
            if target == 0:
                res.append(cur[:])
                return
            if target<0:
                return
            for i in range(start,len(candidates)):
                if i>start and candidates[i]==candidates[i-1]:
                    continue
                cur.append(candidates[i])
                dfs(candidates,target-candidates[i],cur,i+1)
                cur.pop()
        dfs(candidates,target,[],0)
        return res

这题不能重复选，所以递归时要从上次的下标+1开始，同时要排序，保证函数同一层不选一个数第二次

class Solution(object):
    def partition(self, s):
        """
        :type s: str
        :rtype: List[List[str]]
        """
        n = len(s)
        res = []
        def dfs(s,n,cur,begin):
            if begin == n:
                res.append(cur[:])
                return
            for i in range(begin,len(s)):
                s1 = s[begin:i+1]
                if s1 != s1[::-1]:
                    continue
                cur.append(s1)
                dfs(s,n,cur,i+1)
                cur.pop()
        dfs(s,n,[],0)
        return res

这题也算是组合问题，其实判断回文串用动态规划的方法更好

        n = len(s)
        f = [[True] * n for _ in range(n)]

        for i in range(n - 1, -1, -1):
            for j in range(i + 1, n):
                f[i][j] = (s[i] == s[j]) and f[i + 1][j - 1]

i设为子串首，j设为子串尾，要知道f[i][j]，就要先知道f[i+1][j-1],所以i从n-1遍历到0，j=i时确定是回文串，不用管，所以j从i+1遍历到n