回溯——排列问题

1.全排列

全排列

class Solution {
    List<List<Integer>> res  = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    boolean[] used;//标记已经选择的元素
    public List<List<Integer>> permute(int[] nums) {
        if(nums.length==0){            
            return res;
        }
        used = new boolean[nums.length];   
        permuteHelper(nums);
        return res;
    }

    void permuteHelper(int[] nums){
        //终止条件
        if(path.size()==nums.length){
            res.add(new ArrayList<>(path));
            return;
        }
        //单层循环
        
        for(int i=0;i<nums.length;i++){
            if(used[i])  continue;//去除已经选择过的数据

           
            path.add(nums[i]);
            used[i]=true;            
            permuteHelper(nums);
            
            //回溯
            used[i] = false;
            path.removeLast();
            
        }
    }
}

2.全排列 II

全排列 II

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    boolean[] used;//去重
    public List<List<Integer>> permuteUnique(int[] nums) {
        used = new boolean[nums.length];
        Arrays.sort(nums);
        //二维数组，设置为false
        Arrays.fill(used,false);
        backTracking(nums,used);
        return res;
    }

    void backTracking(int[] nums, boolean[] used){
        //终止条件
        if(path.size()==nums.length){
            res.add(new ArrayList<>(path));
            return;
        }

        //单层递归
        for(int i=0;i<nums.length;i++){
            //去重,如果同一树枝使用过就跳过
            if(i>0&&nums[i]==nums[i-1]&&used[i-1]==false) continue;
            //如果同一数层没使用过开始处理
            if(used[i]==false){
                path.add(nums[i]);
                used[i]=true;//使用过就标记为true
                backTracking(nums,used);
                used[i]=false;
                path.removeLast();
            }
        }
    }
}