39. 组合总和
思路
-
参数
result:存结果集
path:存单层路径
sum:判断和是否符合条件 -
递归结束条件
当sum==target则储存结果
当sum>target则结束递归 -
单层递归操作
单层for循环依然是从startIndex开始,和组合总和II一样不一样的点是还可以重新取自身,所以递归传入的startIndex不需要加1 -
剪枝操作
对总集合排序之后,如果下一层的sum(就是本层的 sum + candidates[i])已经大于target,就可以结束本轮for循环的遍历。
for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++)
代码实现
class Solution {
private:
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;
}
// 如果 sum + candidates[i] > target 就终止遍历
for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
sum += candidates[i];
path.push_back(candidates[i]);
backtracking(candidates, target, sum, i);
sum -= candidates[i];
path.pop_back();
}
}
public:
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
result.clear();
path.clear();
sort(candidates.begin(), candidates.end()); // 需要排序
backtracking(candidates, target, 0, 0);
return result;
}
};
40.组合总和II
思路
这道题不能重复使用一个元素,但元素集合里可以有重复元素。
- 参数
result、path、sum,和上面的题目一样 - 结束递归条件
当sum>target,直接回退
当sum=target,储存结果并回退 - 单层递归操作
和上一道题差不多,但多了一个去重操作。
去重:先排序,排序后的去重和三数之和、四数之和差不多,都需要判断当前元素是否和前一个元素一样且是否已经访问过,如果一样且已访问则需要去重。
这里有一个很重要的点:
为什么前一个元素未访问才可以去重呢?因为当前一个元素被访问了,那么当前结点和它就是同一层的递归,如果没有访问则是取新重复元素时的新的递归,这时才能剪枝。
如当集合元素为{1,1,2},sum=2。当从第一个1开始访问时{1,1}是符合条件的,不应该去重;但当从第二个1开始访问时,就可以去重了,判断是从哪开始访问的要点就是前一个相同元素是否被访问过了。
if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
continue;
}
代码实现
class Solution {
public:
vector<vector<int>> result;
vector<int> path;
int sum=0;
void backtracking (vector<int> nums,int target,int startIndex,vector<int> &used){
if(sum>target)return ;
if(sum==target){
result.push_back(path);
return ;
}
for(int i=startIndex;i<nums.size();i++){
if(i>0&&nums[i]==nums[i-1]&&used[i-1]==0)continue;
used[i]=1;
path.push_back(nums[i]);
sum+=nums[i];
backtracking(nums,target,i+1,used);
sum-=nums[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);
return result;
}
};
131.分割回文串
思路
- 参数
- 终止条件
遍历到字符串最后位置终止(如果不是回文子串则不可能遍历到最后) - 单层递归条件
startIndex为子串的左边界,i为子串右边界。先判断子串是否为回文子串,如果不是则继续扩大子串右边界,是则存入path。后继续向下遍历,最后再继续回溯操作。
for (int i = startIndex; i < s.size(); i++) {
if (isPalindrome(s, startIndex, i)) { // 是回文子串
// 获取[startIndex,i]在s中的子串
string str = s.substr(startIndex, i - startIndex + 1);
path.push_back(str);
} else { // 如果不是则直接跳过
continue;
}
backtracking(s, i + 1); // 寻找i+1为起始位置的子串
path.pop_back(); // 回溯过程,弹出本次已经添加的子串
}
代码实现
class Solution {
public:
vector<vector<string>> result;
vector<string> path;
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;
}
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)){
string str=s.substr(startIndex,i-startIndex+1);
path.push_back(str);
}
else continue;
backtracking(s,i+1);
path.pop_back();
}
}
vector<vector<string>> partition(string s) {
result.clear();
path.clear();
backtracking(s,0);
return result;
}
};
总结
组合问题:N个数里面按一定规则找出k个数的集合
- 在有n个无重复元素的数组里找k个和为sum的值(不能重复使用一个元素)组合1
- 在有n个无重复元素的数组里找k个和为sum的值(可以重复用一个元素)组合2
- 在有n个有重复元素的数组里找k个和为sum的值(不可以重复用一个元素)组合3
- 在n个数组内分别找一个元素,其n个值和为sum组合4