Given a collection of distinct integers, return all possible permutations.
Example:
Input: [1,2,3]
Output:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]
以示例输入: [1, 2, 3] 为例，如果让我们手写，要做到不重不漏，我们书写的策略可能是这样：“一位一位确定”，这样说比较笼统，具体是这样的：
1、先写以 1 开始的两个排列：[1, 2, 3]、[1, 3, 2]；
2、再写以 2 开始的两个排列：[2, 1, 3]、[2, 3, 1]；
3、最后写以 3 开始的两个排列：[3, 1, 2]、[3, 2, 1]。
如果数组元素多一点的话，也不怕，我们写的时候遵循下面的原则即可：
1、按数组的顺序来（不要求排序，但我们选取元素的顺序是从左到右的），每次排定 1 个元素；
说明：只有按照顺序才能做到不重不漏。
2、新排定的元素一定不能在之前排定的元素中出现。
说明：如果违反了这一条，就不符合“全排列”的定义。
其实让程序帮你找到所有的全排列也是这样的思路。如果不是这样的话，我们要写数组长度这么多层的循环，编码极其困难，代码写出来也非常不好看。
这道题可以作为理解“回溯算法”的入门题。这是一个非常典型的使用 回溯算法 解决的问题。解决回溯问题，我的经验是 一定不要偷懒，拿起纸和笔，把这个问题的递归结构画出来，一般而言，是一个树形结构，这样思路和代码就会比较清晰了。而写代码即是将画出的图用代码表现出来。
思路分析：
方法：“回溯搜索”算法即“深度优先遍历 + 状态重置 + 剪枝”（这道题没有剪枝）
以示例输入: [1, 2, 3] 为例，因为是排列问题，只要我们按照顺序选取数字，保证上一层选过的数字不在下一层出现，就能够得到不重不漏的所有排列。
说明：这里“保证上一层选过的数字不在下一层出现”的意思是我们手写的时候，后面选的数字一定不能是前面已经出现过的。为了做到这一点，我们得使用一个数组长度这么长的额外空间，记为数组 used ，只要“上一层”选了一个元素，我们就得“标记一下”，“表示占位”。
画出树形结构如下图，
这里我们介绍什么是“状态”。
在递归树里，辅助数组 used 记录的情况和当前已经选出数组成的一个排序，我们统称为当前的“状态”。
注意：
1、这里特别说明一点：虽然我的图是一下子展示出来的，但是我想你画出的图应该是一层一层画出来的；
2、在每一层，我们都有若干条分支供我们选择。下一层的分支数比上一层少 1 ，因为每一层都会排定 1 个数，从这个角度，再来理解一下为什么要使用额外空间记录那些元素使用过；
3、全部的“排列”正是在这棵递归树的所有叶子结点。
我们把上面这件事情给一个形式化的描述：问题的解空间是一棵递归树，求解的过程正是在这棵递归树上搜索答案，而搜索的路径是“深度优先遍历”，它的特点是“不撞南墙不回头”。
下面解释“状态重置”。
在程序执行到上面这棵树的叶子结点的时候，此时递归到底，当前根结点到叶子结点走过的路径就构成一个全排列，把它加入结果集，我把这一步称之为“结算”。此时递归方法要返回了，对于方法返回以后，要做两件事情：
（1）释放对最后一个数的占用；
（2）将最后一个数从当前选取的排列中弹出。
事实上在每一层的方法执行完毕，即将要返回的时候都需要这么做。这棵树上的每一个结点都会被访问 2 次，绕一圈回到第 1 次来到的那个结点，第 2 次回到结点的“状态”要和第 1 次来到这个结点时候的“状态”相同，这种程序员赋予程序的操作叫做“状态重置”。
“状态重置”是“回溯”的重要操作，“回溯搜索”是有方向的搜索，否则我们要写多重循环，代码量不可控。
说明：
1、数组 used 记录了索引 i 在递归过程中是否被使用过，还可以用哈希表、位图来代替
2、当程序第 1 次走到一个结点的时候，表示考虑一个数，要把它加入列表，经过更深层的递归又回到这个结点的时候，需要“状态重置”、“恢复现场”，需要把之前考虑的那个数从末尾弹出，这都是在一个列表的末尾操作，最合适的数据结构是栈（Stack）。
请大家在脑子里想一想程序在这棵递归树上“深度优先遍历”执行的路径，理解了“状态重置”这个概念，是不是觉得“回溯搜索”这个名字很形象。
如果序列包含重复数字，这就是 「力扣」第 47 题：“全排列 II”，需要做“剪枝”操作，做法可以参考《回溯 + 剪枝（Python 代码、Java 代码）》。
参考代码 1 是全排列问题我个人觉得比较好的写法，可以作为写回溯算法的模板，类似的问题写出来的代码基本都是这个样子。
class Solution {
public:
vector<vector<int>> permute(vector<int>& num) {
vector<vector<int>> res;
vector<int> out, visited(num.size(), 0);
permuteDFS(num, 0, visited, out, res);
return res;
}
void permuteDFS(vector<int>& num, int level, vector<int>& visited, vector<int>& out, vector<vector<int>>& res) {
if (level == num.size()) {res.push_back(out); return;}
for (int i = 0; i < num.size(); ++i) {
if (visited[i] == 1) continue;
visited[i] = 1;
out.push_back(num[i]);
permuteDFS(num, level + 1, visited, out, res);
out.pop_back();
visited[i] = 0;
}
}
};
总结：
可以通过这个例子理解“回溯”算法的“状态重置”的操作，“回溯搜索” = “深度优先遍历 + 状态重置 + 剪枝”。（“剪枝”可以通过第 47 题来理解。）
1、“深度优先遍历” 就是“不撞南墙不回头”；
2、回头的时候要“状态重置”，即回到上一次来到的那个地方，“状态”要和上一次来的时候一样。
3、在代码上，往往是在执行下一层递归的前后，代码的形式是“对称的”。
方法二：递归（参考）
使用递归的思想如下，个人感觉没有回溯算法经典：
首先，排在第 1 位，可能的情况有 n 种，剩下的 n - 1 位数的排列可以递归求解；
不过要解决的 1 个问题是，剩下的 n - 1 位数的排列不能够包括排在第 1 位的那个数，根据“选择排序”的思想，把剩下的 n - 1 位数依次交换到第 1 位即可。
例如：[1, 2, 3, 4] 的全排列可以由下面 4 种情况得到：
1 + permute([2, 3, 4])
2 + permute([1, 3, 4])
3 + permute([1, 2, 4])
4 + permute([1, 2, 3])
根据这个思路，编码如下，注意：在递归方法执行以后，需要再执行一次交换操作，这一步是状态重置的操作，从这一点上说，和方法一的思路是一样的。
参考代码 4：
class Solution {
public:
vector<vector<int>> permute(vector<int>& nums) {
vector<vector<int>> res;
permute(nums,res,0);
return res;
}
void permute(vector<int> &nums,vector<vector<int>> &res,int level)
{
if(level >= nums.size())
{
res.push_back(nums);
return ;
}
for(int i = level;i < nums.size();i++)
{
swap(nums[level],nums[i]);
permute(nums,res,level+1);
swap(nums[level],nums[i]);
}
}
};
因此，回溯算法的总体框架总结如下：
result = []
def backtrack(路径, 选择列表):
if 满足结束条件:
result.add(路径)
return
for 选择 in 选择列表:
做选择
backtrack(路径, 选择列表)
撤销选择
来源：CSDN
作者：Lei_lz
链接：https://blog.csdn.net/weixin_37992828/article/details/103492443