代码随想录算法训练营第二十七天|39. 组合总和 40.组合总和II 131.分割回文串

目录

LeeCode 39. 组合总和

LeeCode 40.组合总和II

LeeCode 131.分割回文串 

---

LeeCode 39. 组合总和

39. 组合总和 - 力扣（LeetCode）

思路：因为元素可以重复选取，故抽象成树形结构如下图——

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

求和问题中，排序后剪枝是常见套路。  

---

LeeCode 40.组合总和II

40. 组合总和 II - 力扣（LeetCode）

与上题区别在于每个数字在每个组合中只能使用一次 且 本题 candidates 的元素有重复的。

思路：集合中有重复元素，但是答案中不能有重复的组合，故需要对同一树层上使用过的数字进行去重。树层去重需要对数组排序。

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;
		}
		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();
		}
	}
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
    	path.clear();
    	result.clear();
    	sort(candidates.begin(), candidates.end());
    	backtracking(candidates, target, 0, 0);
    	return result;
    }
};

---

LeeCode 131.分割回文串 

131. 分割回文串 - 力扣（LeetCode）

思路：切割+判断回文，切割类似于组合，利用回溯法解决，将切割问题抽象为树形结构如图：

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