（算法）全排列————＜递归＞

1. 题⽬链接：46.全排列 

2. 题⽬描述：

3. 解法：

算法思路： 

典型的回溯题⽬，我们需要在每⼀个位置上考虑所有的可能情况并且不能出现重复。通过深度优先搜 索的⽅式，不断地枚举每个数在当前位置的可能性，并回溯到上⼀个状态，直到枚举完所有可能性， 得到正确的结果。

每个数是否可以放⼊当前位置，只需要判断这个数在之前是否出现即可。具体地，在这道题⽬中，我 们可以通过⼀个递归函数backtrack和标记数组visited来实现全排列。 

递归函数设计：void backtrack(vector>& res, vector& nums,  vector& visited, vector& ans, int step, int len)

参数：step（当前需要填⼊的位置），len（数组⻓度）；

返回值：⽆；

函数作⽤：查找所有合理的排列并存储在答案列表中。  

递归流程如下：

1. ⾸先定义⼀个⼆维数组res⽤来存放所有可能的排列，⼀个⼀维数组ans⽤来存放每个状态的排 列，⼀个⼀维数组visited标记元素，然后从第⼀个位置开始进⾏递归；

2. 在每个递归的状态中，我们维护⼀个步数step，表⽰当前已经处理了⼏个数字； 

3. 递归结束条件：当step等于nums数组的⻓度时，说明我们已经处理完了所有数字，将当前数组 存⼊结果中；

4. 在每个递归状态中，枚举所有下标i，若这个下标未被标记，则使⽤nums数组中当前下标的元 素：

        a. 将visited[i]标记为1；

        b. ans数组中第step个元素被nums[i]覆盖； 

        c. 对第step+1个位置进⾏递归； 

        d. 将visited[i]重新赋值为0，表⽰回溯；

5. 最后，返回res。 

        • 特别地，我们可以不使⽤标记数组，直接遍历step之后的元素（未被使⽤），然后将其与需要递 归的位置进⾏交换即可。 

C++算法代码： 

#include<iostream>
#include<vector>
using namespace std;
class Solution
{
public:
    //答案
    vector<vector<int>>answer;
    //单个答案
    vector<int>ret;
    //状态数组
    bool zhuangtai[11];
    void dfs(vector<int>& nums)
    {
        //出口
        if (nums.size() == ret.size())
        {
            answer.push_back(ret);
            return;
        }
        for (int i = 0; i <nums.size(); i++)
        {
            if (!zhuangtai[i])
            {
                zhuangtai[i] = true;
                ret.push_back(nums[i]);
                dfs(nums);
                ret.pop_back();
                zhuangtai[i] = false;
            }
        }
    }
    vector<vector<int>> permute(vector<int>& nums)
    {
        dfs(nums);
        return answer;
    }
};

Java算法代码：

class Solution
{
	 List<List<Integer>> ret;
	List<Integer> path;
	boolean[] check;
	public List<List<Integer>> permute(int[] nums)
	{
		ret = new ArrayList<>();
		path = new ArrayList<>();
		check = new boolean[nums.length];
		dfs(nums);
		return ret;
	}
	public void dfs(int[] nums)
	{
		if (nums.length == path.size())
		{
			ret.add(new ArrayList<>(path));
			return;
		}
		for (int i = 0; i < nums.length; i++)
		{
			if (check[i] == false)
			{
				path.add(nums[i]);
				check[i] = true;
				dfs(nums);
				// 回溯 -> 恢复现场 
				check[i] = false;
				path.remove(path.size() - 1);
			}
		}
	}
}