找数组中不重复元素的和(回溯算法)

给定一个数组 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]
]
思路分析：
对于组合问题，一般可以抽象为树形结构，树的宽度一般就是数组中元素的个数，树的深度一般暂时无法确定。
对于题目中说的不允许元素重复使用，可以将这个树形结构进行抽象，那么此时"使用过的元素"便可以分为两个维度进行理解，分别是树的的宽度层次上(同一层上该元素是否被使用)；还有就是深度层次上(同一树枝上该元素是否被使用过)。准确的理解这两个层面的元素使用，是解题的关键。
下面，我以树形结构为例在图中将这两层结构进行分析。

图中used的变化如上图所示，可以看到arr[i]=arr[i-1]的情况
used[i-1]=true时，表明同一树枝arr[i-1]使用过；
used[i-1]=false时，表明同一树层arr[i-1]使用过。
c++代码如下

//demo2.h
#pragma once
#include<iostream>
#include<vector>
#include<algorithm>
#include<unordered_set>

using namespace std;

class demo2
{
public:
	void backtracing(int target, int sum, int start, vector<int> arr, vector<bool> &uesd);
	void PrintRest();
private:
	vector<vector<int>> rest;
	vector<int> path;
};

//demo2.cpp
#include "demo2.h"

void demo2::backtracing(int target, int sum, int start , vector<int> arr, vector<bool> &used) {
	if (sum == target) {
		rest.push_back(path);
		return;
	}
	for (int i = start; i < arr.size() && sum + arr[i] <= target; i++) {
		// 同一树层上使用过
		if (i > 0 && arr[i] == arr[i - 1] && used[i - 1] == false) {
			continue;
		}
		sum += arr[i];
		path.push_back(arr[i]);
		used[i] = true;
		backtracing(target, sum, i + 1, arr, used);
		//回溯
		sum -= arr[i];
		path.pop_back();
		used[i] = false;
	}
}
void demo2::PrintRest() {
	for (int i = 0; i < rest.size(); i++) {
		for (int j = 0; j < rest[i].size(); j++) {
			cout << rest[i][j] << " ";
		}
		cout << endl;
	}
}

//main.cpp
#include"demo2.h"
using namespace std;
int main() {
	demo2 d2;
	vector<int> arr = { 1,1,1,2,2,3,4 };
	vector<bool> used = { 0,0,0,0,0,0,0 };
	d2.backtracing(5, 0, 0, arr, used);
	d2.PrintRest();
}

结果如下