Leetcode # 46. Permutations 全排列 解题报告

1 解题思想

这道题是全排列，做法很多，而且Leetcode上随后也会有更多的变种

这道题的假设是：distinct ，不重复，所以是最简单的一个，问题解法有两种：
1、设立一个状态数组，标示是否选择了，然后递归的方式搜索所有可能的组合，这在我给的代码里是backtracking那个标记
2、从第一个数开始，不停的与他之后的数字进行交换，每当操作到了n次的一种组合后就加入列表，停止搜索，有dfs标记那个代码是

明天会介绍一些更好的方法，去适应更多的情况。

请记住今天的是：不重复的数组！

2 原题

Given a collection of distinct numbers, return all possible permutations.

For example,
[1,2,3] have the following permutations:
[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], and [3,2,1].

3 AC解（两种方式）

public class Solution {
    List<List<Integer>> list;
    public List<Integer> toList(int nums[]){
        List<Integer> list=new ArrayList<Integer>();
        for(int i=0;i<nums.length;i++)
            list.add(nums[i]);
        return list;
    }
    public void swap(int[] nums,int a,int b){
        int tmp=nums[a];
        nums[a]=nums[b];
        nums[b]=tmp;
    }
    public void dfs(int[] nums,int index){
        if(index==nums.length)
            list.add(toList(nums));
        for(int i=index;i<nums.length;i++){
                swap(nums,i,index);
                dfs(nums,index+1);
                swap(nums,index,i);
        }
    }
    //从第一个数开始，不停的与他之后的进行交换，中间有DFS
    public List<List<Integer>> permute(int[] nums) {
        list=new ArrayList<List<Integer>>();
        if(nums.length==0)
            return list;
        dfs(nums,0);
        return list;
    }

    /**
    List<List<Integer>> list;
    int track[];
    boolean flag[];
    int nums[];
    int n;
    //直接回溯，不过据说有一种交换的方式可以实现哦哦。。我试试
    public void backtrack(int index){
        if(index==n){
            List<Integer> tmp=new ArrayList<Integer>();
            for(int j=0;j<n;j++)
                tmp.add(track[j]);
            list.add(tmp);
            return ;
        }
        for(int i=0;i<n;i++){
            if(flag[i]==false){
                track[index]=nums[i];
                flag[i]=true;
                backtrack(index+1);
                flag[i]=false;
            }
        }
    }
    public List<List<Integer>> permute(int[] nums) {
        list=new ArrayList<List<Integer>>();
        if(nums.length==0)
            return list;
        track=new int[nums.length];
        flag=new boolean[nums.length];
        n=nums.length;
        this.nums=nums;
        backtrack(0);
        return list;

    }**/
}