代码随想录算法训练营day23 |39. 组合总和 、40.组合总和II 、131.分割回文串

碎碎念：加油
参考：[代码随想录](https://programmercarl.com/0039.%E7%BB%84%E5%90%88%E6%80%BB%E5%92%8C.html

39. 组合总和

题目链接

39. 组合总和

思想

本题相对于昨天做到的组合总和Ⅲ，没有限定组合里元素的数量。通过和来限定深度，只是这个深度要通过给出的组合数来综合看。
树形图：

定义两个全局变量，二维数组result，一位数组path。
回溯三部曲：

1. 参数和返回值：返回值void，参数：candidate，target，sum，startIndex
2. 终止条件：如果sum>target，直接return，如果sum==target，加入result，返回。
3. 单层搜索的逻辑：i从startIndex开始，遍历candidate，把i放到path中，修改sum，递归（i）【元素可以重复使用，之前元素不能重复使用的时候传入的是i+1】，把i弹出来，修改sum。
   剪枝优化：
   对candidate做一个排序，之和只要有一个组合>target，之后的分支都没有必要去遍历了。

题解

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& candidates, int target, int sum, int startIndex) {
        if (sum > target) return;
        if (sum == target) {
            result.push_back(path);
            return;
        }

        for (int i = startIndex; i < candidates.size(); i ++) {
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates, target, sum, i); // 这里用i是因为本题中的元素可以重复使用
            sum -= candidates[i];
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        backtracking(candidates, target, 0, 0);
        return result;
    }
};

class Solution:
    def __init__(self):
        self.path = []
        self.result = []
    
    def backtracking(self, candidates, target, currentSum, startIndex):
        if currentSum == target:
            self.result.append(self.path[:])
            return
        
        for i in range(startIndex, len(candidates)):
            if currentSum + candidates[i] > target:
                break
            currentSum += candidates[i]
            self.path.append(candidates[i])
            self.backtracking(candidates, target, currentSum, i)
            currentSum -= candidates[i]
            self.path.pop()

    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        candidates.sort()
        self.backtracking(candidates, target, 0, 0)
        return self.result

反思

注意本题的元素是可以重复使用的，体现在代码里就是递归传startIndex的时候传入的是i而不是i+1。

40.组合总和II

题目链接

40.组合总和II

思想

本题的集合中是有重复元素的，而本题又强调结果中不能有重复的结果，所以本题需要去重。
树形图：

定义一个一维向量path，定义一个二维向量result。
在主函数里对nums做排序，方面后面的去重。
回溯三部曲：

1. 参数和返回值：参数有nums，targetSum，sum，startIndex，used数组
2. 终止条件：如果num>targetSum，返回；如果num==targetSum，把path放入result，返回。
3. 单层搜索逻辑：for循环，i从startIndex开始。
   如果当前遍历的元素和前一个元素相同（注意防止越界访问，i要>0），且used[i-1]=0 （当used[i-1]=1的时候，我们是在树枝的方向上，此时不能去重），此时continue。【关键的去重过程】
   把nums[i]放入path，修改sum，修改used，递归(i+1)，修改sum，修改used，把nums[i]从path弹出（回溯过程）。

题解

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& candidates, int target, int sum, int startIndex, vector<bool>& used) {
        if (sum == target) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target;i++) {
            if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) continue;
            sum += candidates[i];
            path.push_back(candidates[i]);
            used[i] = true;
            backtracking(candidates, target, sum, i + 1, used);
            used[i] = false;
            sum -= candidates[i];
            path.pop_back();
        }

    }
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<bool> used(candidates.size(), false);
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0, used);
        return result;
    }
};

class Solution:
    def backtracking(self, candidates, target, currentSum, startIndex, used, path, result):
        if currentSum == target:
            result.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 currentSum + candidates[i] > target:
                break
            currentSum += candidates[i]
            path.append(candidates[i])
            used[i] = True
            self.backtracking(candidates, target, currentSum, i + 1, used, path, result)
            used[i] = False
            path.pop()
            currentSum -= candidates[i]
        
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        path = []
        result = []
        used = [False] * len(candidates)
        candidates.sort()
        self.backtracking(candidates, target, 0, 0, used, path, result)
        return result

反思

本题的难点就在于去重，要区分好树层去重和树枝去重。

131.分割回文串

题目链接

131.分割回文串

思想

树形图：

定义一维数组path，定义二维数组result
回溯三部曲：

1. 参数和返回值：参数有字符串s，startIndex，返回值为void
2. 终止条件：startIndex就是切割线，如果startIndex >= s.size，收集结果到result，return
3. 单层搜索的逻辑：
   for循环，i从startIndex开始，[startIndex, i]是子串的范围；
   判断子串是否是回文的：写一个函数，参数是字符串，子串的起始位置，子串的终止位置，返回值是boolean类型。具体实现是两边一起向中间搜索来判断；
   如果是回文的，path收集区间，如果不是回文的，直接continue；
   递归逻辑(i+1)，path.pop()，这是回溯的操作。
   return;

题解

class Solution {
private:
    vector<vector<string>> result;
    vector<string> path;
    void backtracking(const string& s, int startIndex) {
        if (startIndex >= s.size()) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i < s.size(); i++) {
            if (isPalindrome(s, startIndex, i)) {
                string str = s.substr(startIndex, i - startIndex +1);
                path.push_back(str);
            } else {
                continue;
            }
            backtracking(s, i + 1); // 暗含回溯
            path.pop_back();
        }
    }
    bool isPalindrome(const string& s, int start, int end) {
        for (int i = start, j = end; i < j; i ++, j--) {
            if (s[i] != s[j])  return false;
        }
        return true;
    }
public:
    vector<vector<string>> partition(string s) {
        backtracking(s, 0);
        return result;
    }
};

class Solution:
    def backtracking(self, s, startIndex, path, result):
        if startIndex == len(s):
            result.append(path[:])
            return
        
        for i in range(startIndex, len(s)):
            if self.isPalindrome(s, startIndex, i):
                path.append(s[startIndex:i+1])
                self.backtracking(s, i+1, path, result)
                path.pop()

    def isPalindrome(self, s, start, end):
        i = start
        j = 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]]:
        result = []
        path = []
        self.backtracking(s, 0, path, result)
        return result