回溯算法--LeetCode-46 全排列、LeetCode-47 全排列Ⅱ

LeetCode-46 全排列

题目链接：https://leetcode-cn.com/problems/permutations/

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

示例:

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

    public List> permute(int[] nums) {
        List> result = new ArrayList<>();
        int[] flag = new int[nums.length];
        reback(nums, result, new ArrayList(), flag);
        return result;
    }

    // 回溯算法 方法一
    // 1、flag为数组数字是否被使用的标记
    // 可以优化：可以减少一半的工作量 [1,2,3]和[3,2,1]对称，重复计算
    public static void reback(int[] nums, List> result, List temp, int[] flag){
        if (temp.size() == nums.length) {
            result.add(new ArrayList<>(temp));
            return;
        }
        for (int i = 0, length = nums.length; i < length; i++) {
            if (flag[i] == 0) {
                flag[i] = 1;
                temp.add(nums[i]);
                reback(nums, result, temp, flag);
                temp.remove(temp.size() - 1);
                flag[i] = 0;
            }
        }
    }

    // 回溯算法 方法二
    public void reback(int[] nums, List> result, int start) {
        if (start == (nums.length - 1)) { // 递归到数组最后一位，添加数据至结果数组
            List list = new ArrayList<>(); // 为新的排列创建一个数组容器
            for (int i=0, length = nums.length; i< length; i++) {
                list.add(nums[i]);
            }
            result.add(list); // 将新的排列组合存放起来
            return;
        }
        for (int i = start, length = nums.length; i < length; i++) {
            // 1、交换数组第一个元素与后续的元素（包括第一个元素）
            int temp = nums[start];
            nums[start] = nums[i];
            nums[i] = temp;
            // 2、递归后续元素
            reback(nums, result, start + 1);
            // 3、数组状态还原
            nums[i] = nums[start];
            nums[start] = temp;
        }
    }

LeetCode-47 全排列Ⅱ 

题目链接：https://leetcode-cn.com/problems/permutations-ii/

给定一个可包含重复数字的序列，返回所有不重复的全排列。

示例:

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

    public List> permuteUnique(int[] nums) {
        List> result = new ArrayList<>();
        int[] flag = new int[nums.length];
        Arrays.sort(nums);
        reback(nums, result, new ArrayList(), flag);
        return result;
    }

    // 回溯算法
    // 1、flag为数组数字是否被使用的标记
    public static void reback(int[] nums, List> result, List temp, int[] flag){
        if (temp.size() == nums.length) {
            result.add(new ArrayList<>(temp));
            return;
        }
        int lastUsed = Integer.MIN_VALUE;
        for (int i = 0, length = nums.length; i < length; i++) {
            if (flag[i] == 0 && nums[i] != lastUsed) {// 去重：如果当前数与上次递归的数字相同，continue
                flag[i] = 1;
                temp.add(nums[i]);
                reback(nums, result, temp, flag);
                lastUsed = nums[i];
                temp.remove(temp.size() - 1);
                flag[i] = 0;
            }
        }
    }