分治、回溯
分治和回溯本质上还是递归：找到问题的重复性
找到问题的重复性，分解问题，找到子问题，解决子问题，子问题结果再组合
最优重复性就是动态规划
一、分治：代码模板：
1）结束条件：到了最底层，到了叶子节点，没有子问题了
2）处理操作：处理当前问题，就是怎么把大问题分解成小问题
类似，求N的阶乘：N*FUNC（N-1）
斐波那契数列：FUNC（N-1）+FUNC（N-2）
3）调用函数下探：调用函数，下探到下层，下一层的问题
4）最后组装结果：
自顶向下的解决方式：当前层就解决当前层的问题
二、回溯：
Backtracking
采用试错的思想，采用分步法解决问题，当发现现有的分步不能得到正确解答的时候，他将取消上一步
或者几步的计算，再通过其它可能的分步找到答案
采用递归实现，有两种情况：
1）找到可能的正确答案
2）再尝试了所有的分步方式后还是没有找到答案
最坏情况下，会导致复杂度为指数时间
例题：
生成合法括号：
1、一个「合法」括号组合的左括号数量一定等于右括号数量，这个很好理 解。
2、对于一个「合法」的括号字符串组合 p ，必然对于任何 0 <= i < len(p) 都有:子串 p[0..i] 中左括号的数量都大于或等于右括号的数量。
回溯算法：
方法一还有改进的余地：我们可以只在序列仍然保持有效时才添加 '(' or ')'，而不是像 方法一 那样每次添加。
我们可以通过跟踪到目前为止放置的左括号和右括号的数目来做到这一点，
如果左括号数量不大于 n，我们可以放一个左括号。如果右括号数量小于左括号的数量，我们可以放一个右括号。
class Solution {
void backtrack(vector<string>& ans, string& cur, int open, int close, int n) {
// 回溯算法套路，路径、选择列表
//满足结束条件
if (cur.size() == n * 2) {
ans.push_back(cur);
return;
}
if (open < n) {
//做出选择
cur.push_back('(');
//回溯
backtrack(ans, cur, open + 1, close, n);
//撤销选择
cur.pop_back();
}
if (close < open) {
cur.push_back(')');
backtrack(ans, cur, open, close + 1, n);
cur.pop_back();
}
}
public:
vector<string> generateParenthesis(int n) {
vector<string> result;
string current;
backtrack(result, current, 0, 0, n);
return result;
}
};
关于回溯，更详细的介绍：https://mp.weixin.qq.com/s/gjSgJbNbd1eAA5WkA-HeWw
什么是回溯法
回溯法也可以叫做回溯搜索法，它是一种搜索的方式。
在二叉树系列中，我们已经不止一次，提到了回溯，例如二叉树：以为使用了递归，其实还隐藏着回溯。
回溯是递归的副产品，只要有递归就会有回溯。
「所以以下讲解中，回溯函数也就是递归函数，指的都是一个函数
回溯法的效率
回溯法的性能如何呢，这里要和大家说清楚了，「虽然回溯法很难，很不好理解，但是回溯法并不是什么高效的算法」。
「因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案」，如果想让回溯法高效一些，可以加一些剪枝的操作，但也改不了回溯法就是穷举的本质。
那么既然回溯法并不高效为什么还要用它呢？
因为没得选，一些问题能暴力搜出来就不错了，撑死了再剪枝一下，还没有更高效的解法。
此时大家应该好奇了，都什么问题，这么牛逼，只能暴力搜索。
回溯法解决的问题
回溯法，一般可以解决如下几种问题：
- 组合问题：N个数里面按一定规则找出k个数的集合
- 排列问题：N个数按一定规则全排列，有几种排列方式
- 切割问题：一个字符串按一定规则有几种切割方式
- 子集问题：一个N个数的集合里有多少符合条件的子集
- 棋盘问题：N皇后，解数独等等
「相信大家看着这些之后会发现，每个问题，都不简单！」
另外，会有一些同学可能分不清什么是组合，什么是排列？
「组合是不强调元素顺序的，排列是强调元素顺序」。
例如：{1, 2} 和 {2, 1} 在组合上，就是一个集合，因为不强调顺序，而要是排列的话，{1, 2} 和 {2, 1} 就是两个集合了。
记住组合无序，排列有序，就可以了。
如何理解回溯法
「回溯法解决的问题都可以抽象为树形结构」，是的，我指的是所有回溯法的问题都可以抽象为树形结构！
因为回溯法解决的都是在集合中递归查找子集，「集合的大小就构成了树的宽度，递归的深度，都构成的树的深度」。
递归就要有终止条件，所以必然是一颗高度有限的树（N叉树）。
这块可能初学者还不太理解，后面的回溯算法解决的所有题目中，我都会强调这一点并画图举相应的例子，现在有一个印象就行。
回溯法模板
这里给出Carl总结的回溯算法模板。
在讲二叉树的递归中我们说了递归三部曲，这里我再给大家列出回溯三部曲。
- 回溯函数模板返回值以及参数
在回溯算法中，我的习惯是函数起名字为backtracking，这个起名大家随意。
回溯算法中函数返回值一般为void。
再来看一下参数，因为回溯算法需要的参数可不像二叉树递归的时候那么容易一次性确定下来，所以一般是先写逻辑，然后需要什么参数，就填什么参数。
但后面的回溯题目的讲解中，为了方便大家理解，我在一开始就帮大家把参数确定下来。
- 回溯函数终止条件
既然是树形结构，那么我们在讲解二叉树的递归的时候，就知道遍历树形结构一定要有终止条件。
所以回溯也有要终止条件。
什么时候达到了终止条件，树中就可以看出，一般来说搜到叶子节点了，也就找到了满足条件的一条答案，把这个答案存放起来，并结束本层递归。
所以回溯函数终止条件伪代码如下：
- 回溯搜索的遍历过程
在上面我们提到了，回溯法一般是在集合中递归搜索，集合的大小构成了树的宽度，递归的深度构成的树的深度。
for循环就是遍历集合区间，可以理解一个节点有多少个孩子，这个for循环就执行多少次。
backtracking这里自己调用自己，实现递归。
大家可以从图中看出「for循环可以理解是横向遍历，backtracking（递归）就是纵向遍历」，这样就把这棵树全遍历完了，一般来说，搜索叶子节点就是找的其中一个结果了。
分析完过程，回溯算法模板框架如下：
回溯函数伪代码如下：
void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}
}
「这份模板很重要，后面做回溯法的题目都靠它了！」
如果从来没有学过回溯算法的录友们，看到这里会有点懵，后面开始讲解具体题目的时候就会好一些了，已经做过回溯法题目的录友，看到这里应该会感同身受了。
总结
本篇我们讲解了，什么是回溯算法，知道了回溯和递归是相辅相成的。
接着提到了回溯法的效率，回溯法其实就是暴力查找，并不是什么高效的算法。
然后列出了回溯法可以解决几类问题，可以看出每一类问题都不简单。
最后我们讲到回溯法解决的问题都可以抽象为树形结构（N叉树），并给出了回溯法的模板。
今天是回溯算法的第一天，按照惯例Carl都是先概述一波，然后在开始讲解具体题目，没有接触过回溯法的同学刚学起来有点看不懂很正常，后面和具体题目结合起来会好一些。
例子
给定一个无重复元素的数组 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] ]
class Solution {
private:
vector<vector <int>> results;
vector<int> solution;
public:
void backtracking(vector<int> candidates, int target, int start){
if(target < 0)
return;
if(target == 0){
results.push_back(solution);
return;
}
for(int i=start; i<candidates.size() && candidates[i]-target<=0; i++){
solution.push_back(candidates[i]);
backtracking(candidates, target-candidates[i], i);
solution.pop_back();
}
}
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
std::sort(candidates.begin(), candidates.end());
backtracking(candidates, target, 0);
return results;
}
};
给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。
示例:
输入: n = 4, k = 2 输出: [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ]
注意：for循环每次从开始 Index开始遍历，然后用path保存取到的节点i，然后调用回溯，然后撤销处理结果；
class Solution {
public:
vector<vector<int>> res;
vector<int> path;
void backtracking(int n,int k,int index){
if(path.size()==k){
res.push_back(path);
return;
}
for(int i=index;i<=n;i++){
path.push_back(i);
backtracking(n,k,i+1);
path.pop_back();
}
}
vector<vector<int>> combine(int n, int k) {
backtracking(n,k,1);
return res;
}
};
46.全排列
题目链接：https://leetcode-cn.com/problems/permutations/
给定一个 没有重复 数字的序列，返回其所有可能的全排列。
示例:
输入: [1,2,3]
输出:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]
class Solution {
public:
// 路径:记录在 track 中
// 选择列表:nums 中不存在于 track 的那些元素
// 结束条件:nums 中的元素全都在 track 中出现
vector<vector<int>> res;
vector<vector<int>> permute(vector<int>& nums) {
vector<int> track;
backtrack(nums,track);
return res;
}
void backtrack(vector<int>& nums,vector<int>& track){
// 触发结束条件
if(track.size()==nums.size()){
res.push_back(track);
return;
}
for(int i=0;i<nums.size();i++){
// 做选择,排除不合法的选择
if(find(track.begin(), track.end(),nums[i])!=track.end()){
continue;
}
track.push_back(nums[i]);
// 进入下一层决策树
backtrack(nums,track);
// 取消选择
track.pop_back();
}
}
};
47. 全排列 II
给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。
示例 1：
输入：nums = [1,1,2]
输出：
[[1,1,2],
[1,2,1],
[2,1,1]]
示例 2：
输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
相比于上一题，这个题的改变在于输入的数组有重复的数字，所以相比较于上一个代码，
只需要在递归前判断是否是重复的就可以，如何判断是否重复呢？就是扫描k到i之间[k,i)之间是否与nums[i]有相同的数字，
如果有，就是重复的，因为这一轮从k到m的递归之中相同的数据交换得到的集合也是相同的，全排列也是相同的。
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
void backtracking (vector<int>& nums, vector<bool>& used) {
// 此时说明找到了一组
if (path.size() == nums.size()) {
result.push_back(path);
return;
}
for (int i = 0; i < nums.size(); i++) {
// used[i - 1] == true，说明同一树支nums[i - 1]使用过
// used[i - 1] == false，说明同一树层nums[i - 1]使用过
// 如果同一树层nums[i - 1]使用过则直接跳过
if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
continue;
}
if (used[i] == false) {
used[i] = true;
path.push_back(nums[i]);
backtracking(nums, used);
path.pop_back();
used[i] = false;
}
}
}
public:
vector<vector<int>> permuteUnique(vector<int>& nums) {
result.clear();
path.clear();
sort(nums.begin(), nums.end()); // 排序
vector<bool> used(nums.size(), false);
backtracking(nums, used);
return result;
}
};
