文章链接： 39. 组合总和、 40.组合总和II、 131.分割回文串

视频链接： 39. 组合总和、 40.组合总和II、 131.分割回文串

题目链接： 39. 组合总和、 40.组合总和II、 131.分割回文串

39.组合总和

思路：

此题与前面组合相关题目的区别是，可以有重复的数组元素。

与前面题目代码的区别就是 “递归部分” ，backtracking(candidates, target, sum, i);   中用 i ,而不用 i+ 1表示可以重复读取当前的数。


剪枝思路：

如果 sum + candidates[i] > target 就终止遍历。

// 如果 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();
 }
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.

整体代码：

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

    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() && sum + candidates[i] <= target; i++) {
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates, target, sum, i); // 注意是 i
            sum -= candidates[i];
            path.pop_back();
        }
    }

    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;
    }
};
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.


40.组合总和II

思路：

与上题的区别：

1.每个数字在每个组合中只能使用 一次； 

2.所给数组是可能包含有重复元素的；

注意：解集中要注意去除重复的集合；

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

    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() && sum + candidates[i] <= target; i++) {
            if(i > startIndex && candidates[i] == candidates[i - 1]) { // 除去重复的结果
                continue;
            }
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates, target, sum, i + 1);
            sum -= candidates[i];
            path.pop_back();
        }
    }

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        result.clear();
        path.clear();
        if(candidates.size() == 0) {
            return result;
        }
        sort(candidates.begin(), candidates.end()); // 注意，要排序（让相同的元素挨在一起）
        backtracking(candidates, target, 0, 0);
        return result;
    }
};
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.

理解：

一个for循环表示树的分支；

一个递归表示树的深度；


131.分割回文串

思路：

1.递归函数（深度）：移动指向字符串开始指针；

2.for循环（宽度）：移动截取字串的结束指针；

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(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;
    }

    vector<vector<string>> partition(string s) {
        result.clear();
        path.clear();
        backtracking(s, 0);
        return result;
    }
};
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.