46. Permutations

46. 全排列

给定一个没有重复数字的序列，返回其所有可能的全排列。

示例:

输入: [1,2,3]
输出:
[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

解法一（调库函数）：

//时间复杂度O(?), 空间复杂度O(n!)
class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        vector<vector<int>> res;
        do {
            res.push_back(nums);
        } while(next_permutation(nums.begin(), nums.end()));
        return res;
    }
};

解法二（下一个排列）：

//时间复杂度O(n! * nlogn), 空间复杂度O(n!)
class Solution {
public:
    void nextPermutation(vector<int>& nums) {//O(nlogn)
        int n = nums.size();
        for(int i = n - 2; i >= 0; i--) {
            if(nums[i] < nums[i + 1]) {
                int minI = i + 1;
                for(int j = minI; j < n; j++) {
                    if(nums[j] > nums[i] && nums[minI] > nums[j]) minI = j;
                }
                swap(nums[i], nums[minI]);
                sort(nums.begin() + i + 1, nums.end());
                return;
            }
        }
        sort(nums.begin(), nums.end());
    }
    
    vector<vector<int>> permute(vector<int>& nums) {//O(n!)
        sort(nums.rbegin(), nums.rend());
        vector<int> minimum(nums);
        
        vector<vector<int>> res;
        do {
            nextPermutation(nums);
            res.push_back(nums);
        } while(nums != minimum);
        
        return res;
    }
};

解法三（回溯）：

//时间复杂度O(n * n!), 空间复杂度O(n!)
class Solution {
public:
    void DFS(vector<int>& nums, vector<int>& cur, unordered_set<int>& us, vector<vector<int>>& res) {
        if(cur.size() == nums.size()) {
            res.push_back(cur);
            return;
        }
        
        for(int i = 0; i < nums.size(); i++) {
            if(!us.count(nums[i])) {
                cur.push_back(nums[i]);
                us.insert(nums[i]);
                DFS(nums, cur, us, res);
                cur.pop_back();
                us.erase(nums[i]);
            }
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> res;
        vector<int> cur;
        unordered_set<int> us;
        
        DFS(nums, cur, us, res);
        return res;
    }
};

解法一：

直接调用C++算法库里的函数next_permutation。先按升序排序（从最小排列开始），然后反复求下一个排列并保存。

解法二：

库函数next_permutation在第31题里其实已经实现过了，这里不使用库函数，而是使用31题的代码，生成下一个排列，思路和解法一同。

解法三：

回溯法。思路和第39、40题（组合总和、组合总和Ⅱ）类似。

2019/10/01 12:36