Leetcode 46. Permutations

46. Permutations

• Total Accepted: 112369
• Total Submissions: 300018
• Difficulty: Medium

 

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],
  [3,2,1]
]

 

 

思路：回溯法，具体见代码。

方法一是递归的回溯法，比较典型。

 

方法二比方法一更加快，也更加巧妙。

 

方法三是递推的回溯法，比如[1,2,3]的结果：

1.有1个插入位置，只插入第1个元素：[1]

2.有2个插入位置，只插入第2个元素：

由[1]插入2变化而来：[2,1] [1,2]

3.有3个插入位置，只插入第3元素：

由[2,1]插入3变化而来：[3,2,1] [2,3,1] [2,1,3]

由[1,2]插入3变化而来：[3,1,2] [1,3,2] [1,2,3]

所以结果是[3,2,1] [2,3,1] [2,1,3] [3,1,2] [1,3,2] [1,2,3]

 

只要注意如何设定生成顺序，依次产生有效结果即可。

 

代码：

方法一：28 ms

class Solution {
public:
    void permute(vector<vector<int> > &res,vector<int> nums,vector<int> v,unordered_set<int> used,int cur){
        if(cur==nums.size()){
            res.push_back(v);
            return;
        }
        for(int i=0;i<nums.size();i++){
            if(used.erase(nums[i])){
                v.push_back(nums[i]);
                permute(res,nums,v,used,cur+1);
                v.pop_back();
                used.insert(nums[i]);
            }
        }
    }
    vector<vector<int> > permute(vector<int>& nums) {
        unordered_set<int> used;
        for(int i=0;i<nums.size();i++){
            used.insert(nums[i]);
        }
        vector<vector<int> > res;
        vector<int> v;
        permute(res,nums,v,used,0);
        return res;
    }
};

 

 

方法二：12 ms

参考https://discuss.leetcode.com/topic/5881/my-elegant-recursive-c-solution-with-inline-explanation/2

class Solution {
public:
    vector<vector<int> > permute(vector<int> &num) {
        vector<vector<int> > result;
        permuteRecursive(num, 0, result);
        return result;
    }
    
    // permute num[begin..end]
    // invariant: num[0..begin-1] have been fixed/permuted
    void permuteRecursive(vector<int> &num, int begin, vector<vector<int> > &result)    {
        if (begin >= num.size()) {
            // one permutation instance
            result.push_back(num);
            return;
        }
        
        for (int i = begin; i < num.size(); i++) {
            swap(num[begin], num[i]);
            permuteRecursive(num, begin + 1, result);
            // reset
            swap(num[begin], num[i]);
        }
    }
};

 

方法三：40 ms

class Solution {
public:
    vector<vector<int> > permute(vector<int>& nums) {
        vector<vector<int> > res;
        vector<int> v(1,nums[0]);
        res.push_back(v);
        for(int i=1;i<nums.size();i++){
            int size=res.size();
            for(int j=0;j<size;j++){
                v=res[0];
                res.erase(res.begin());
                for(int k=0;k<=v.size();k++){
                   v.insert(v.begin()+k,nums[i]);
                   res.push_back(v);
                   v.erase(v.begin()+k);
                }
            }
        }
        return res;
    }
};