1.组合总和
思路:
1.数组中 无重复的元素,所以不需要去重操作。
2.本题可以重复使用一个元素。
3.一个集合!!!
class Solution {
public:
vector<int> path;
vector<vector<int>> result;
void backtraceing(vector<int>& candidates,int target,int sum,int startIndex){
if(sum == target){
result.push_back(path);
return ;
}
if(sum > target) return ;
for(int i = startIndex;i < candidates.size();i++){
sum += candidates[i];
path.push_back(candidates[i]);
backtraceing(candidates,target,sum,i);
sum -= candidates[i];
path.pop_back();
}
}
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
path.clear();
result.clear();
backtraceing(candidates,target,0,0);
return result;
}
};
2.组合总和2
思路:
1.数组中有重复的元素,但是每个元素只能使用一次,需要去重操作。
2.集合(数组candidates)有重复元素,但还不能有重复的组合。
3.所谓去重,其实就是使用过的元素不能重复选取。
class Solution {
public:
vector<int> path;
vector<vector<int>> result;
void backtracking(vector<int>& candidates,int target,int sum,vector<bool>& used,int startIndex){
if(sum > target) return;
if(sum == target){
result.push_back(path);
return ;
}
for(int i = startIndex;i < candidates.size();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,used,i + 1);
sum -= candidates[i];
path.pop_back();
used[i] = false;
}
return ;
}
vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
path.clear();
result.clear();
vector<bool> used(candidates.size(),false);
sort(candidates.begin(),candidates.end());
backtracking(candidates,target,0,used,0);
return result;
}
};
3.分割回文串
思路:
1.代码中的startIndex就是树形图中的切割线。
2.切割字串的范围是:[start Index,i]。
3.substr(),s.substr()
是用于提取字符串子串的函数,其中s
是一个字符串对象。
class Solution {
public:
vector<string> path;
vector<vector<string>> result;
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(isP(s,startIndex,i)){
string str = s.substr(startIndex,i - startIndex +1);
path.push_back(str);
}
else continue;
backtracking(s,i + 1);
path.pop_back();
}
return ;
}
bool isP(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;
}
vector<vector<string>> partition(string s) {
path.clear();
result.clear();
backtracking(s,0);
return result;
}
};