回溯回溯，排列问题

//1、排列问题：数组中和为8的元素，一个元素可重复选。
输入：nums = { 2,3,5 }; target = 8;
输出：{
[2,2,2,2],
[2,3,3],
[3,2,3],
[3,3,2],
[3,5],
[5,3]
}

class Solution {
public:
	vector<vector<int>> result;
	vector<int> path;
	vector<vector<int>> combinationSum4(vector<int>& nums, int target) {
		backtracking(nums, target, 0);
		return result;
	}
	
	void backtracking(vector<int>& nums, int target, int nowSum) {
		if (nowSum == target) {
			result.push_back(path);
			return;
		}
		if (nowSum >= target) {
			return;
		}
		for (int i = 0; i < nums.size(); i++) {
			path.push_back(nums[i]);
			nowSum += nums[i];
			backtracking(nums, target, nowSum);
			nowSum -= nums[i];
			path.pop_back();
		}
	}
};

//2、排列问题：数组中和为8的元素，一个元素不可重复选。
输入：nums = { 2,3,5 }; target = 8;
输出：{
[3,5],
[5,3]
}

class Solution {
public:
	vector<vector<int>> result;
	vector<int> path;
	vector<vector<int>> combinationSum4(vector<int>& nums, int target) {
		vector<bool> used(nums.size(), 0);
		backtracking(nums, target, 0, used);
		return result;
	}

	void backtracking(vector<int>& nums, int target, int nowSum, vector<bool> used) {
		if (nowSum == target) {
			result.push_back(path);
			return;
		}
		if (nowSum >= target) {
			return;
		}
		for (int i = 0; i < nums.size(); i++) {
			if (used[i] == 1) continue;
			used[i] = 1;
			path.push_back(nums[i]);
			nowSum += nums[i];
			backtracking(nums, target, nowSum, used);
			nowSum -= nums[i];
			path.pop_back();
			used[i] = 0;
		}
	}
};

//3、排列问题：一个数组中所有元素进行全排列，一个元素不可重复选。
输入：nums = { 2,3,5 };;
输出：{
[2,3,5],
[2,5,3],
[3,2,5],
[3,5,2],
[5,2,3]
[5,3,2]
}

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

		for (int i = 0; i < candidates.size(); i++) {
			if (used[i] == true) continue;
			used[i] = true;
			path.push_back(candidates[i]);
			backtracking(candidates, used);
			path.pop_back();
			used[i] = false;
		}
	}
};

//4、排列问题：一个数组中所有元素进行全排列，一个元素可重复选。
输入：nums = { 2,3,5 };
输出：{
[2,2,2]
[2,2,3]
[2,3,5],
[2,5,3],
[3,2,5],
[3,5,2],
[5,2,3]
[5,3,2]
…
[5,5,5]
}

class Solution {
public:
	vector<vector<int>> result;
	vector<int> path;
	vector<vector<int>> combinationSum2(vector<int>& candidates) {
		backtracking(candidates);
		return result;
	}
	void backtracking(vector<int>& candidates) {
		if (path.size() == candidates.size()) {
			result.push_back(path);
			return;
		}

		for (int i = 0; i < candidates.size(); i++) {
			path.push_back(candidates[i]);
			backtracking(candidates);
			path.pop_back();
		}
	}
};

**//5、全排列 数组中有重复元素返回不重复的集合
输入：nums = { 2,2,5 };
输出：{
[2,2,5]
[2,5,2]
[5,2,2]
}
**

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

		for (int i = 0; i < candidates.size(); i++) {
			if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
				continue;
			}
			if (used[i] == true) continue;
			used[i] = true;
			path.push_back(candidates[i]);
			backtracking(candidates, used);
			path.pop_back();
			used[i] = false;
		}
	}
};