个人笔记，回溯，c++。力扣78，子集问题

本人想找个平台记录自己的写题感想，以免自己过后忘了。

写回溯题要明白模板：

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

路径，也就是startindex。

for控制左右选择，startindex控制往下选择。

疑惑问题：不是直接退回。把上一层的数遍历，直到那个数的for结束，在退到上一层继续操作
xxxxxxxx
组合结束用path为起点是因为只收集这么多，下面说不定还有。
子集结束用start index是因为到达最底层在收集
xxxxxxxxx
子集。
先收集添加，然后到达底层在开始退出当前递归，开始尝试其他路径。

上题

代码

#include<iostream>
#include<algorithm>
#include<string>
#include<cmath>
#include<vector>
using namespace std;
vector<int>path;
vector<vector<int>>result;
void backtracking(vector<int> &n, int startindex)
{
	result.push_back(path);//先保存在结束
	if (startindex >= n.size())
	{
		return;
	}
	for (int i = startindex; i <=n.size()-1; i++)
	{
		path.push_back(n[i]);//预处理
		backtracking(n, i + 1);//控制下
		path.pop_back();//回溯，退回上一层
	}
}

int main()
{

	vector<int>n;
	n.push_back(1);
	n.push_back(2);
	n.push_back(3);
	backtracking(n, 0);
	for (auto i : result)
	{
		for (auto j : i)
		{
			cout << j;
		}
		cout << endl;
	}
	return 0;
}

 代码没有写完，还有个空集，到时后，输入就行

0000000000000000000000000000000000000

去重版本

要去重的是“同一树层上的使用过”，如何判断同一树层上元素（相同的元素）是否使用过了呢。

如果n[i] == n[i - 1] 并且 used[i - 1] == false，就说明：前一个树枝，使用了n[i - 1]，也就是说同一树层使用过n[i - 1]。

此时for循环里就应该做continue的操作。

• used[i - 1] == true，说明同一树枝n[i - 1]使用过
• used[i - 1] == false，说明同一树层n[i - 1]使用过

为什么 used[i - 1] == false 就是同一树层呢，因为同一树层，used[i - 1] == false 才能表示，当前取的 n[i] 是从 n[i - 1] 回溯而来的。

#include<iostream>
#include<algorithm>
#include<string>
#include<cmath>
#include<vector>
using namespace std;
vector<int>path;
vector<vector<int>>result;
void backtracking(vector<int> &n, int startindex, vector<bool>&use)
{
	result.push_back(path);
	for (int i = startindex; i <n.size(); i++)
	{
            //在candidates[i] == candidates[i - 1]相同的情况下：
            // used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
            // used[i - 1] == false，说明同一树层candidates[i - 1]使用过
            // 而我们要对同一树层使用过的元素进行跳过
		if (i > 0 && n[i] == n[i - 1] && use[i-1] ==false)
		{
			continue;
		}

		path.push_back(n[i]);
		use[i] = true;//一开始没使用过
		backtracking(n, i + 1,use);
		use[i] = false;//如果回溯了就说明这个数使用过了
		path.pop_back();
	}
}

int main()
{
	vector<int>n;
	n.push_back(1);
	n.push_back(2);
	n.push_back(2);
	vector<bool> use(n.size(), false);//需要给use输入一个初始条件
	sort(n.begin(), n.end());
	backtracking(n, 0,use);
	for (auto i : result)
	{
		for (auto j : i)
		{
			cout << j;
		}
		cout << endl;
	}
	return 0;
}