力扣 #46. 全排列（回溯法&&剪枝）

#46. 全排列

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

示例:

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

思路：

• 一般输出所有结果的题目，都是用回溯算法进行深度搜索。
• 回溯算法一般是如下过程：

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

代码：

LeetCode版

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        int size = nums.length;
        int[] visited = new int[nums.length];
        generate(res,new ArrayList<Integer>(),nums,visited);
        return res;
    }
    public void generate(List<List<Integer>> res, List<Integer> ans, int[] nums, int[] visited){
    	//满足条件，add路径。
        //长度是size，添加进结果。
        if(ans.size() == nums.length){
            res.add(new ArrayList<>(ans));
            return;
        } 
        //初始状态下，ans是空
        //让每个数字都有开头的机会
        //nums的所有数字都可以被选择
        for(int i = 0; i< nums.length;i++){
            if(visited[i] == 1) continue;
			//做选择
            //取出第i个数字，并标记为1。
            visited[i] = 1;
            ans.add(nums[i]);
            generate(res,ans,nums,visited);
            //撤销选择
            visited[i] = 0;
            ans.remove(ans.size()-1);
        }
    }
}

IDEA版

import java.util.ArrayList;
import java.util.List;

public class number_46 {
    public static void main(String[] args) {
        int[] nums = {1,2,3};
        List<List<Integer>> ll;
        ll = permute(nums);
        System.out.println(ll);
    }

    public static List<List<Integer>> permute(int[] nums){
        //结果数组
        List<List<Integer>> result = new ArrayList<>();
        //标记被访问过的数字
        int[] visited = new int[nums.length];
        //使用回溯法求解
        back_track(result,new ArrayList<Integer>(),nums,visited);
        return result;
    }

    public static void back_track(List<List<Integer>> result, List<Integer> temp, int[] nums, int[] visited){
        //一次回溯的结果，保存进result,并剪枝。
        if(temp.size() == nums.length){
            result.add(new ArrayList<>(temp));
            return;
        }
        //循环选择第一个进temp的元素
        for (int i = 0; i < nums.length; i++) {
            //跳过访问过的元素，剪枝。
            if(visited[i] == 1) continue;
            //标记被访问过的元素
            visited[i] = 1;
            temp.add(nums[i]);
            //递归
            back_track(result,temp,nums,visited);
            //恢复现场,并将尾部弹出。
            visited[i] = 0;
            temp.remove(temp.size()-1);
        }
    }
}