Leetcode 46 47 Permutation, 77 combination

Permutation

class Solution {
    List<List<Integer>> res = new ArrayList<List<Integer>>();
    int visited[];
    public List<List<Integer>> permute(int[] nums) {
        visited = new int[nums.length];
        //foreach pos, get tall number
        ArrayList<Integer> pos = new ArrayList<>();
        back(pos,nums, visited);
        return res;
    }
    void back(ArrayList<Integer> pos, int[] nums, int[] visited){
        if(pos.size()>=nums.length){
            List<Integer> temp =new ArrayList<>(pos);//!!!!!!!!!!!why copy this, immunatable like string (always deal with only one list)
            res.add(temp);
            return;
        }
        for(int i = 0; i<nums.length; i++){
            if(visited[i]==0){
                pos.add(nums[i]);
                visited[i] = 1;//index of nums
                back(pos, nums,visited);
                visited[i] = 0;
                pos.remove(pos.size()-1);
            }
        }
    }
}

the structure of backtracking

why copy the list

generic list

47: duplicate elements

if contains the element

class Solution {
    List<List<Integer>> res = new ArrayList<List<Integer>>();
    int visited[];
    public List<List<Integer>> permuteUnique(int[] nums) {
        visited = new int[nums.length];
        //foreach pos, get tall number
        ArrayList<Integer> pos = new ArrayList<>();
        back(pos,nums, visited);
        return res;
    }
    void back(ArrayList<Integer> pos, int[] nums, int[] visited){
        if(pos.size()>=nums.length){
            List<Integer> temp =new ArrayList<>(pos);//!!!!!!!!!!!why copy this, immunatable like string (always deal with only one list)
            if(!res.contains(temp))
                res.add(temp);
            return;
        }
        for(int i = 0; i<nums.length; i++){
            if(visited[i]==0){
                pos.add(nums[i]);
                visited[i] = 1;//index of nums
                back(pos, nums,visited);
                visited[i] = 0;
                pos.remove(pos.size()-1);
            }
        }

    }
}

why both using visited array

Because we can only use each element once

Combination accoring order

class Solution {
    //for each position(two) set number
    List<List<Integer>> res = new ArrayList<List<Integer>>();
    boolean[] visited ;
    public List<List<Integer>> combine(int n, int k) {
        visited = new boolean[n+1];
        back(0, n,k, new ArrayList<Integer>(),1);
        return res;
    }
    void back(int pos, int n, int k, List<Integer> list, int num){
        if(pos>=k){
            List<Integer> temp = new ArrayList(list);
            res.add(temp);
            return;
        }
        for(int i = num; i<=n; i++){
            if(!visited[i]){
                list.add(i);
                visited[i] = true;
                back(pos+1, n, k, list,i+1);
                visited[i] = false;
                list.remove(list.size()-1);
            }
        }
    }
}

//

check the num in back function

we need increasing number because (1,2) and (2,1) are the same things

//prev: 137 317 (without order)
//contains 1 2 3 , 1 2 3,
//visited 1 1 5, 1 5 1, visite element once for each path