[Leetcode] Permutations

I have two solutions for this problem, the first one is from the undergraduate stage, the second one is from the CTCI (permute string)

The common point of the two methods lies in the recursive method they both used.

1. Enumerate the head

First method sounds more efficient. For the integer list, if will enumerate the first integer in the range of the current list.

For example, [1,2,3,4,5]

first integer can be:

1, [2,3,4,5]

    2,[3,4,5] 3,[2,4,5] 4,[2,3,5] 5,[2,3,4]

2, [1,3,4,5]

3, [1,2,4,5]

4, [1,2,3,5]

5, [1,2,3,4]

when the head is chosen, the left sub list can be regarded as a smaller problem with the same method. The recursive function will return when the last index reached. We should use a list to track the

selected element in each layer of the recursive.

The best run time of this method is 300ms

            //after swap back 17,18，19, it may be disorder, however the order here is not required.
            //通过不断的枚举开始元素，可能会导致剩下的部分不是有序的
            //1 2 3 4 ->
            //2 1 3 4,3 2 1 4, 4 2 3 1
            //但是这里顺序是没有要求的,所以可以这样简单粗暴的解决

import java.util.*;

public class Solution {
    private void backtrack(List<List<Integer> > lists, int []nums, int index){
        if(index==nums.length){
            List<Integer> tl=new LinkedList<Integer>();
            for(int element: nums){
                tl.add(element);
            }
            lists.add(tl);
        }
        for(int i=index;i<nums.length;i++){
            int tmp=nums[i];
            nums[i]=nums[index];
            nums[index]=tmp;
            backtrack(lists,nums,index+1);
这里一定要将元素交换换来，因为这样可以保证在后面的交换当中不会产生和前面的重复
            tmp=nums[i];
            nums[i]=nums[index];
            nums[index]=tmp;
        }
    }
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer> > lists = new LinkedList<List<Integer> >();
        backtrack(lists,nums,0);
        return lists;
    }
}

如果输出需要是有序的，那么需要保持在当前的首位元素的调整当中后面的元素时候有序的，并且当从当前递归层次返回时，应该保持原来的顺序。需要改为如下的代码

    private void DFS_sorted(List<List<Integer>> res,int [] nums, int start){
        if(start==nums.length){
            List<Integer> tmpres = new LinkedList<Integer>();
            for(int num:nums){
                tmpres.add(num);
            }
            res.add(tmpres);
            return;
        }
        for(int i=start;i<nums.length;i++){//枚举所有的开始元素
            int tmp = nums[start];
            nums[start] = nums[i];
            nums[i] = tmp;
            DFS(res,nums,start+1);
//这里没有必要交换回来，因为他们下次交换可以保证剩下的部分仍然是有序的[start+1,length]
        }
//[start,length]是无序的，需要交换回来
        Arrays.sort(nums,start,nums.length); 
    }

 

2. insert method

The second method uses the insert strategy.

First we remove the first integer, then permute the remain list and insert the removed element into the premutation result.

The best run time of this method is 336ms

public class Solution {
    private List<List<Integer>> permuteutil(int []nums,int index){
        List<List<Integer>> listres = new LinkedList<List<Integer>>();
        if(index==nums.length-1) {
            List<Integer> listnew = new LinkedList<Integer>();
            listnew.add(nums[index]);
            listres.add(listnew);
            return listres;
        }
        int first = nums[index];
        List<List<Integer>> leftperm = permuteutil(nums,index+1);
        for(List<Integer> tmplist: leftperm){
            // the insert position should include the tail next position ,just the tmplist.size().
            for(int i=0;i<=tmplist.size();i++){
                List<Integer> listnew = new LinkedList<Integer>();
                listnew.addAll(tmplist);
                listnew.add(i,first);
                listres.add(listnew);
            }
        }
        return listres;
    }
    public List<List<Integer>> permute(int[] nums) {
        return permuteutil(nums,0);
    }
}