day27|LeetCode:● 39. 组合总和● 40.组合总和II● 131.分割回文串

题目链接：39. 组合总和

1.思路

选择可以等于target的几个组合，可以重复选

本题是 集合里元素可以用无数次，那么和组合问题的差别 其实仅在于 startIndex上的控制

2.回溯法

class Solution {
public:
vector<vector<int>>result;
vector<int>path;
void backtracking(vector<int>& candidates, int target, int sum, int startindex) {
    if (sum == target) {
       result.push_back(path);
       return;
    }
    for (int i = startindex; i < candidates.size() && candidates[i] + sum <= target; i++) {
        path.push_back(candidates[i]);
        sum += candidates[i];
        backtracking(candidates, target, sum, i);
        sum -= candidates[i];
        path.pop_back();
    }
} 
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0);
        return result;
    }
};

 3.回溯三部曲

1.确定递归函数参数

这里除了需要题目给的那些参数外，因为需要求和（边遍历边求），所以需要一个num参数（sum）,因为下次递归不能重复遍历上次遍历的元素，就需要一个startindex来确定每层遍历的起始位置

因为可以重复选择，所以startindex不需要加1，从当前i进行递归

2.确定终止条件

当sum > target说明不符合，提前结束，但是 可以剪枝，我们发现sum == target就加入结果集中，返回到回溯函数

3.确定单层搜索的逻辑

每次递归一次就加入当前层的值，树枝搜索，当满了后就加入结果集中，返回回溯函数，到上一层for循环的下一层，进行树层搜索

4.注意点

树枝搜索和树层搜索的遍历时间和顺序不相同

1.树枝搜索是一层一层的搜索，一般都是靠着递归函数backtrackin来实现的。 每次递归一次加一个数

2.树层搜索一般是回溯来主导的，每次回溯都到下一层for循环，加入树这一行的下一个

5.剪枝

剪枝一般在终止条件和for循环中，根据函数参数进行推导

当对目标数组进行完排序后，当sum>target时return，但是会回溯而去遍历这一层的for循环的下一层，但是这一层是排序过的，后面必定更大，所以不需要再遍历后面了，提前结束这层for循环到上一层的for循环再加

  for (int i = startindex; i < candidates.size() && candidates[i] + sum <= target; i++) {

---

40. 组合总和 II

1.思路

注意题目中给我们 集合是有重复元素的，那么求出来的 组合有可能重复，但题目要求不能有重复组合。

因为需要不同组合，但是可以有组合中可以有相同元素，所以这里需要用到去重避免选到相同组合

2.回溯法+剪枝

class Solution {
public:
vector<int>path;
vector<vector<int>>result;

void backtracking(vector<int>& candidates, int target, int startindex, vector<int>& used, int num) {
    if (num == target) {
        result.push_back(path);
        return;
    }
    for (int i = startindex; i < candidates.size() && num + candidates[i] <= target; i++) {
        if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == 0) {
            continue;
        }
        used[i] = 1;
        path.push_back(candidates[i]);
        num += candidates[i];
        backtracking(candidates, target, i + 1, used, num);
        num -= candidates[i];
        path.pop_back();
        used[i] = 0;
    }
}
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<int>used(candidates.size(), 0);
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, used, 0);
        return result;
    }
};

3.递归三部曲

1.确定递归函数参数

除了题目给的参数外，还需要sum统计现在path中加起来的数，因为避免重复，防止访问以前的数据，就需要有一个startindex,因为这个可以有重复元素，但是不能有重复组合，我们就需要一个判断重复元素的used;

used作用：

在排序完后的数组中如果当前元素后上一个元素相同，就需要判断是否处于树枝搜索状态，还是处于树层搜索状态，当处于树枝搜索，可以有重复元素，即使被用过了还可以用，如果是树层元素，如果和上一层相同就会在后面遍历相同的数据，就需要continue掉。

2.确定终止条件

当遇到sum==taregt就结束了，也开头剪枝

3.确定单层搜索的逻辑

排序后树层遍历（靠递归函数），这里需要判断能不能加入这个数进入path中，也是为了去重，当现在的这个元素与上一个元素相同时，如果是树枝搜索遍历过还可以遍历，所以就能加入，但树层遍历时，因为弹出了以前的used，所以现在又变成0了，这里比较后就不能加

• used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
• used[i - 1] == false，说明同一树层candidates[i - 1]使用过

4.注意

选择加不加到path数组中在for循环下面就需要判断，加入result就需要在终止条件中判断。

---

题目链接：131. 分割回文串

1.思路

就是判断一下字符串是否回文串，是回文串就加入到path数组中，直到遍历到s的最后结束

例如对于字符串abcdef：

• 组合问题：选取一个a之后，在bcdef中再去选取第二个，选取b之后在cdef中再选取第三个.....。
• 切割问题：切割一个a之后，在bcdef中再去切割第二段，切割b之后在cdef中再切割第三段.....。

切割其实就是当前for循环的startindex和i的切割

2.回溯法

class Solution {
public:
vector<string>path;
vector<vector<string>>result;
bool isPalindrome(string& s, int m, int n) {
   for (int i = m,j = n;i < j; i++,j--) {
       if (s[i] != s[j]) return false;
   }
   return true;
}
void backtracking(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)) {
            path.push_back(s.substr(startindex, i - startindex + 1));
        } else {
            continue;
        }
        backtracking(s, i + 1);
        path.pop_back();
    }
}
    vector<vector<string>> partition(string s) {
        backtracking(s, 0);
        return result;
    }
};

3.回溯三部曲

1.确定递归函数参数

除了题目给出的参数，还需要一个startindex，确定当前切割块的起始位置，同时为了切割以前的

2.确定终止条件

当所有切割情况都遍历完了就可以结束了。就是当前下标出去了（因为从0开始，就需要有=号）

3.确定单层递归函数

那么在代码里什么是切割线呢？

在处理组合问题的时候，递归参数需要传入startIndex，表示下一轮递归遍历的起始位置，这个startIndex就是切割线。

所以终止条件代码如下：

void backtracking (const string& s, int startIndex) {
    // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
    if (startIndex >= s.size()) {
        result.push_back(path);
        return;
    }
}

如果这一层切割的字符串是回文子串就加入到path中，不然就进行树层遍历到for循环的下一层，更改切割点。是就加入到path中，进行树枝遍历下一层。再判断，当startindex出去后就返回到回溯函数进行回溯，到下一树层。判断再加

其实就是把这一层的startindex当作成左边界，层序遍历后的i是右边界，就是现在变成了加入 的元素变成了右边界，startindex变成了左边界