算法练习 DAY27 || 39. 组合总和 40.组合总和II 131.分割回文串

39. 组合总和

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：

所有数字（包括 target）都是正整数。
解集不能包含重复的组合。

示例 1： 输入：candidates = [2,3,6,7], target = 7, 所求解集为： [ [7], [2,2,3] ]

示例 2： 输入：candidates = [2,3,5], target = 8, 所求解集为： [ [2,2,2,2], [2,3,3], [3,5] ]

思路：
与组合的思路是一样的，唯一的区别就在于单个元素可以重复利用。
backtracking(candidates, target, i); // 关键点:不用i+1了，表示可以重复读取当前的数

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

	void backtracking(vector<int>& candidates, int target, int startIndex) {
		if (sum > target) return;
		if (sum == target) {
			result.push_back(path);
			return;
		}

		for (int i = startIndex; i < candidates.size(); i++) {
			path.push_back(candidates[i]);
			sum += candidates[i];
			backtracking(candidates, target, i); // 关键点:不用i+1了，表示可以重复读取当前的数
			sum -= candidates[i];
			path.pop_back();
		}
	}
	vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
		backtracking(candidates, target, 0);
		return result;
	}
};

剪枝

剪枝：初始版本里面 进入下层循环再判断sum > target
剪枝里可以在for循环里就加判断，先排序
如果sum + candidates[i] > target 就可以直接返回了

class Solution1 {
public:
	vector<int> path;
	vector<vector<int>> result;
	int sum = 0;
	void backtracking(vector<int>& candidates, int target, 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, i);
			sum -= candidates[i];
			path.pop_back();
		}
	}
	vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
		path.clear();
		result.clear();
		sort(candidates.begin(), candidates.end());
		backtracking(candidates, target, 0);
		return result;
	}
};

40.组合总和II

给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

说明： 所有数字（包括目标数）都是正整数。 解集不能包含重复的组合。

示例 1: 输入: candidates = [10,1,2,7,6,1,5], target = 8, 所求解集为: [ [1, 7], [1, 2, 5], [2, 6], [1, 1, 6] ]

示例 2: 输入: candidates = [2,5,2,1,2], target = 5, 所求解集为: [ [1,2,2], [5] ]

难点：
数组中有重复元素，但是最后结果中不可以有重复的
遍历的时候有树枝遍历和一层树遍历，要在层里面进行去重。
回看一下题目，元素在同一个组合内是可以重复的，怎么重复都没事，但两个组合不能相同。
所以我们要去重的是同一树层上的“使用过”，同一树枝上的都是一个组合里的元素，不用去重。

class Solution {
public:
	vector<int> path;
	vector<vector<int>> result;
	int sum = 0;
	
	void backtracking(vector<int>& candidates, int target,int startIndex,vector<bool>& used) {
		if (sum == target) {
			result.push_back(path);
			return;
		}

		for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) { //剪枝
			// used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
			// used[i - 1] == false，说明同一树层candidates[i - 1]使用过
			// 要对同一树层使用过的元素进行跳过
			if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
				continue;
			}
			//首先i至少大于0 保证i-1不会越界
			//数组在传进来之前已经进行过排序 所以直接看相邻两个元素是不是一样
			//如果一样就要看这个值有没有在层中被使用过
			sum += candidates[i];
			path.push_back(candidates[i]);
			used[i] = true; 
			backtracking(candidates, target, i + 1,used);
			used[i] = false; //只有回溯回来的元素才会在这里被指为false 
			sum -= candidates[i];
			path.pop_back();
		}
	}

	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);
		return result;
	}

};

131.分割回文串

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串

示例 1：

输入：s = “aab”
输出：[[“a”,“a”,“b”],[“aa”,“b”]]

示例 2：

输入：s = “a”
输出：[[“a”]]

递归用来纵向遍历，for循环用来横向遍历，切割线（就是图中的红线）切割到字符串的结尾位置，说明找到了一个切割方法。

class Solution {
public:
	vector<string> path;// 放已经回文的子串
	vector<vector<string>> result;

	void backtracking(const string& s, int startIndex) {
		// 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
		if (startIndex >= s.size()) {
			result.push_back(path);
			return;
		}

		for (int i = startIndex; i < s.size(); i++) {
			if (isPalindrome(s, startIndex, i)) {
				// 获取[startIndex,i]在s中的子串
				//如果是回文就切割然后放进path
				string str = s.substr(startIndex, i-startIndex+1);
				path.push_back(str);
			}
			else {
				continue;
			}
			backtracking(s, i + 1); // 寻找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) {
		path.clear();
		result.clear();
		backtracking(s, 0);
		return result;
	}
};