39. 组合总和

 1 class Solution {
 2 private:
 3     vector<vector<int>> result;
 4     vector<int> vec;
 5     void back_tracking(const vector<int>& candidates, int target,int start, int sum){
 6         if(sum == target){
 7             result.push_back(vec);
 8         }
 9         if(sum > target)    return;
10         for(int i = start; i < candidates.size(); i++){
11             vec.push_back(candidates[i]);
12             sum += candidates[i];
13             back_tracking(candidates, target, i, sum);
14             vec.pop_back();
15             sum -= candidates[i];
16         }
17     }
18 
19 public:
20     vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
21         sort(candidates.begin(),candidates.end());
22         back_tracking(candidates, target, 0, 0);
23         return result;
24     }
25 };

40. 组合总和 II

新增一个used集合用来去重。

 1 class Solution {
 2 private:
 3     vector<vector<int>> result;
 4     vector<int> vec;
 5     void back_tracking(const vector<int>& candidates,int target, int start, int sum, vector<bool>& used){
 6         if(sum == target){
 7             result.push_back(vec);
 8             return;
 9         }
10         if(sum > target)    return;
11         for(int i = start; i < candidates.size(); i++){
12             if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
13                 continue;
14             }
15             vec.push_back(candidates[i]);
16             used[i] = true;
17             back_tracking(candidates, target, i+1, sum+candidates[i],used);
18             vec.pop_back();
19             used[i] = false;
20         }
21     }
22 public:
23     vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
24         sort(candidates.begin(),candidates.end());
25         vector<bool> used(candidates.size(),false);
26         back_tracking(candidates, target, 0, 0, used);
27         return result;
28     }
29 };

131. 分割回文串

 1 class Solution {
 2 private:
 3     vector<vector<string>> result;
 4     vector<string> path;
 5     void back_tracking(const string& s, int start){
 6         if(start >= s.size()){
 7             result.push_back(path);
 8             return;
 9         }
10         for(int i = start; i < s.size(); i++){
11             if(is_parrtion(s, start, i)){
12                 string str = s.substr(start,i - start + 1);
13                 path.push_back(str);
14             }else{
15                 continue;
16             }
17             back_tracking(s, i + 1);
18             path.pop_back();
19         }
20     }
21     bool is_parrtion(const string& s, int start, int end){
22         while(start < end){
23            if(s[start] != s[end])   return false;
24            start++;
25            end--;
26         }
27         return true;
28     }
29 public:
30     vector<vector<string>> partition(string s) {
31         back_tracking(s, 0);
32         return result;
33     }
34 };