回溯算法框架——解决全排列问题能力（首先你要清除理解递归）

1.回溯算法框架（遍历多叉树一样）

解决一个回溯问题，实际上就是一个决策树遍历的问题，这是一个框架（三部曲）：
* 路径: 当前所做过的选择
* 选择列表：当前可以供给选择的列表
* 结束条件：决策树走到底层，无法继续向下的时候

result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return
    
    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

其核心就是 for 循环里面的递归，在递归调用之前「做选择」，在递归调用之后「撤销选择」

2.案例（全排列问题）

给定一个 没有重复 数字的序列，返回其所有可能的全排列。

示例:
输入: [1,2,3]
输出:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]

那么我们当时是怎么穷举全排列的呢？比方说给三个数 [1,2,3]，你肯定不会无规律地乱穷举，一般是这样：

先固定第一位为 1，然后第二位可以是 2，那么第三位只能是 3；然后可以把第二位变成 3，第三位就只能是 2 了；然后就只能变化第一位，变成 2，然后再穷举后两位……

现在可以解答开头的几个名词：[2] 就是「路径」，记录你已经做过的选择；[1,3] 就是「选择列表」，表示你当前可以做出的选择；「结束条件」就是遍历到树的底层，在这里就是选择列表为空的时候。

如果明白了这几个名词，可以把「路径」和「选择」列表作为决策树上每个节点的属性

核心框架：

for 选择 in 选择列表:
    # 做选择
    将该选择从选择列表移除
    路径.add(选择)
    backtrack(路径, 选择列表)
    # 撤销选择
    路径.remove(选择)
    将该选择再加入选择列表

题解代码：

package algrithom;

import org.junit.Test;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class Solution {
    List<List<Integer>> list = new LinkedList<>();
    public List<List<Integer>> permute(int[] nums) {
        LinkedList<Integer> track = new LinkedList<>();
        rool_back(nums,track);
        return list;
    }
    public void rool_back(int[] nums,LinkedList track){
        //回溯结束条件
        if(track.size()==nums.length){
            list.add(new LinkedList<>(track));
            return;
        }
        for(int i =0;i<nums.length;i++){
        	//排除不合法选择
            if(track.contains(nums[i]))
                continue;
            //做选择
            track.add(nums[i]);
            //递归调用
            rool_back(nums,track);
            //撤销选择
            track.removeLast();

        }
    }
}

测试模块：

package algrithom;

import java.util.Scanner;

class SolutionTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String[] s = scanner.nextLine().split(" ");
        int[] nums= new int[s.length];
        for(int i =0;i<s.length;i++){
            nums[i] = Integer.parseInt(s[i]);
        }
        Solution solution = new Solution();
        System.out.println(solution.permute(nums));
    }
}

N个皇后问题也很类似