【算法】回溯时集合操作 保持对象的独立性

题目

/**
 * @Author james
 * @Description 给定一个没有重复数字的序列，返回其所有可能的全排列。 -- 使用数组记录状态
 *  * 示例:
 *  * 输入: [1,2,3]
 * 输出:
 * [
 *   [1,2,3],
 *   [1,3,2],
 *   [2,1,3],
 *   [2,3,1],
 *   [3,1,2],
 *   [3,2,1]
 * ]
 * @date 2019/8/23
 */
@SuppressWarnings({"unchecked"})
public class Solution {

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4};
        new Solution().permute(arr);
    }

    public void permute(int[] nums, boolean[] flag, Stack stack, int capacity, List<List<Integer>> ret) {
        if (nums.length == capacity) { 
            ret.add(stack); /*  -------------  出 bug 的位置 -------------  */
            return;
        }

        // 依次选取数组的元素固定在指定位置
        for (int i = 0; i < nums.length; i++) {
            // 如果有未占位的位置，选择一个元素入栈
            if (!flag[i]) {
                stack.push(nums[i]);
                flag[i] = true;
                // 固定完一个元素后，将剩下元素依次固定
                permute(nums, flag, stack, capacity + 1, ret);
                // 状态重置 ， 如果 fag == [1,0,0,0]已固定了一位，现在可以出现[1,1,0,0] [1,0,1,0] [1,0,0,1]。并且元素
                // 以上三种 flag 的情况分别是 [1, 2, x, x] [1, x, 2, 0] [1, x, x, 2]
                stack.pop();
                flag[i] = false;
            }
        }

    }


    public List<List<Integer>> permute(int[] nums) {
        boolean[] flag = new boolean[nums.length];
        List<List<Integer>> ret = new LinkedList<>();
        Stack<Integer> stack = new Stack<>();
        permute(nums, flag, stack, 0, ret);
        System.out.println(ret);
        return ret;
    }
}

具体bug

输出的集合全没有任何一个元素

        if (nums.length == capacity) { 
            ret.add(stack); /*  -------------  出 bug 的位置 -------------  */
            return;
        }

原因

回溯的时候需要pop掉stack里的元素，同时改变了ret中的对象。

解决方法

ret是结果集，当逻辑是存入一个不可变的对象的时候，一定要new一个新的对象并隔离访问的路径，最好的方式可以是匿名类。

        if (nums.length == capacity) {
            ret.add(new ArrayList<>(stack));
            return;
        }