LeetCode 46. Permutations

原题链接在这里：https://leetcode.com/problems/permutations/

题目：

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].

题解：

For recursion, first figure out what parameters are needed in each state.

Here it needs nums array, boolean array used to track visited before, item and result.

From head of array, get the first num not visited before, mark it as visited, add it to item. Then dfs to next state.

Backtracking needs to revert, remove num from item and mark it not visited.

Stop condition, item size is same as nums length.  

Time Complexity: exponential.

Space: O(nums.length). regardless res.

AC Java:

public class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        if(nums == null || nums.length == 0){
            return res;
        }
        boolean [] used = new boolean[nums.length];
        helper(nums,used,new ArrayList<Integer>(), res);
        return res;
    }
    private void helper(int[] nums, boolean [] used, List<Integer> item, List<List<Integer>> res){
        if(item.size() == nums.length){
            res.add(new ArrayList<Integer>(item));
            return;
        }
        for(int i = 0; i<nums.length; i++){
            if(!used[i]){
                used[i] = true;
                item.add(nums[i]);
                helper(nums,used,item,res);
                item.remove(item.size()-1);
                used[i] = false;
            }
        }
    }
}

AC Python:

class Solution(object):
    def permute(self, nums):
        res = []
        self.dfs(nums, [False] * len(nums), [], res)
        return res
        
    def dfs(self, nums, used, item, res):
        if(len(item) == len(nums)):
            res.append(item[:])
            return
        
        for i in range(len(nums)):
            if not used[i]:
                used[i] = True
                item.append(nums[i])
                self.dfs(nums, used, item, res)
                item.pop()
                used[i] = False

这道题的迭代方法如下：

与Subsets相似，开始时item先加nums[0], 把item加到res里.

然后每次添加新的nums[i], 首先把res里的每一个item拿出来, 用cur表示.

在cur的所有可能位置加上新的元素nums[i], 然后把它加载回res里。

Note: res原有的item不能保留，所以每次扫描res所有item前新建newRes, 添加完新元素nums[i]的item是要加到newRes中去的，所有可能的item都加完后再把newRes赋值回res去。

Time Complexity: exponential.

Space: O(n!). n = nums.length.

AC Java:

public class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        if(nums == null || nums.length == 0){
            return res;
        }
        List<Integer> item = new ArrayList<Integer>();
        item.add(nums[0]);
        res.add(item);
        
        for(int i = 1; i<nums.length; i++){
            List<List<Integer>> newRes = new ArrayList<List<Integer>>();
            for(int j = 0; j<res.size(); j++){
                List<Integer> cur = res.get(j);
                for(int k = 0; k<=cur.size(); k++){
                    // 记得这里要做个copy, 不能直接在原来的cur上加
                    item = new ArrayList<Integer>(cur);
                    item.add(k, nums[i]);
                    newRes.add(item);
                }
            }
            res = newRes;
        }
        return res;
    }
}

类似Combinations, Letter Tile Possibilities.

跟上Permutations II.