一、算法介绍
回溯算法就是把问题的解空间转化为图或树的结构表示，然后使用深度优先搜索策略进行遍历，遍历的过程中记录和寻找所有可行解或者最优解。
基本思想类同于：图的深度优先搜索和二叉树的后序遍历
详细的描述则为：
回溯法按深度优先策略搜索问题的解空间树。首先从根节点出发搜索解空间树，当算法搜索至解空间树的某一节点时，先利用剪枝函数判断该节点是否可行（即能得到问题的解）。如果不可行，则跳过对该节点为根的子树的搜索，逐层向其祖先节点回溯；否则，进入该子树，继续按深度优先策略搜索。
回溯法的基本行为是搜索，搜索过程使用剪枝函数来为了避免无效的搜索。剪枝函数包括两类：1. 使用约束函数，剪去不满足约束条件的路径；2.使用限界函数，剪去不能得到最优解的路径。
问题的关键在于如何定义问题的解空间，转化成树（即解空间树）。解空间树分为两种：子集树和排列树。两种在算法结构和思路上大体相同。
应用：
当问题是要求满足某种性质（约束条件）的所有解或最优解时，往往使用回溯法。它有“通用解题法”之美誉。
实现（递归 和递推（迭代））：
回溯法的实现方法有两种：递归和递推（也称迭代）。一般来说，一个问题两种方法都可以实现，只是在算法效率和设计复杂度上有区别。【类比于图深度遍历的递归实现和非递归（递推）实现】
- 递归
思路简单，设计容易，但效率低，其设计范式如下：
//针对N叉树的递归回溯方法
void backtrack (int t)
{
if (t>n) output(x); //叶子节点，输出结果，x是可行解
else
for i = 1 to k//当前节点的所有子节点
{
x[t]=value(i); //每个子节点的值赋值给x
//满足约束条件和限界条件
if (constraint(t)&&bound(t))
backtrack(t+1); //递归下一层
}
}
2、递推
算法设计相对复杂，但效率高。
//针对N叉树的迭代回溯方法
void iterativeBacktrack ()
{
int t=1;
while (t>0) {
if(ExistSubNode(t)) //当前节点的存在子节点
{
for i = 1 to k //遍历当前节点的所有子节点
{
x[t]=value(i);//每个子节点的值赋值给x
if (constraint(t)&&bound(t))//满足约束条件和限界条件
{
//solution表示在节点t处得到了一个解
if (solution(t)) output(x);//得到问题的一个可行解，输出
else t++;//没有得到解，继续向下搜索
}
}
}
else //不存在子节点，返回上一层
{
t--;
}
}
}
详解：https://blog.csdn.net/weiyuefei/article/details/79316653
二、LeetCode题
1、#310摆动序列
题目
如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。
例如， [1,7,4,9,2,5] 是一个摆动序列，因为差值 (6,-3,5,-7,3) 是正负交替出现的。相反, [1,4,7,2,5] 和 [1,7,4,5,5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。
给定一个整数序列，返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。
示例 1:
输入: [1,7,4,9,2,5]
输出: 6
解释: 整个序列均为摆动序列。
示例 2:
输入: [1,17,5,10,13,15,10,5,16,8]
输出: 7
解释: 这个序列包含几个长度为 7 摆动序列，其中一个可为[1,17,10,13,10,16,8]。
示例 3:
输入: [1,2,3,4,5,6,7,8,9]
输出: 2
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/wiggle-subsequence
解题
我们去找所有可能摆动子序列的长度并找到它们中的最大值。为了实现这样的算法，我们需要一个回溯函数，calculate(nums, index, isUp)，将 nums 作为输入数组，index 记录的是我们从哪个位置开始找最长摆动序列， boolean 变量 isUp 记录的是现在要找的是上升元素还是下降元素。如果函数 calculate 在一个上升摆动之后被调用，我们需要用这个相同的函数找到下降的元素。如果 calculate 在一个下降元素之后被调用，那么我们需要用这个函数找到下一个上升的元素。
public class Solution {
private int calculate(int[] nums, int index, boolean isUp) {
int maxcount = 0;
for (int i = index + 1; i < nums.length; i++) {
if ((isUp && nums[i] > nums[index]) || (!isUp && nums[i] < nums[index]))
maxcount = Math.max(maxcount, 1 + calculate(nums, i, !isUp));
}
return maxcount;
}
public int wiggleMaxLength(int[] nums) {
if (nums.length < 2)
return nums.length;
return 1 + Math.max(calculate(nums, 0, true), calculate(nums, 0, false));
}
}
复杂度分析
时间复杂度： O(n!) 。calculate() 会被调用 n! 次。
空间复杂度： O(n)。回溯深度为 n 。
持续补充对应算法题，欢迎关注