[LeetCode] 46. Permutations

最新推荐文章于 2022-11-23 22:41:13 发布

原创最新推荐文章于 2022-11-23 22:41:13 发布 · 168 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 200 同时被 2 个专栏收录

41 篇文章

订阅专栏

Backtracking

9 篇文章

订阅专栏

本文介绍了一种基于整数集合生成所有可能排列的算法。提供了四种实现方案：深度优先搜索（DFS）、元素交换、递归插入及利用STL库函数。通过这些方法，可以有效地解决全排列问题。

Permutations

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

Example:
Input: [1,2,3]
Output:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]

解析

生成全排列。

解法1：DFS

用一个visited数组表示是否访问，类似于DFS的方法进行搜索。

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        int size = nums.size();
        vector<vector<int> > res;
        vector<bool> visited(size,0);
        Permutation(res,nums, visited, {}, 0);
        return res;
    }
    
    void Permutation(vector<vector<int> >& res, vector<int>& nums, vector<bool>& visited, vector<int> tmp, int index){
        if(index == nums.size()){
            res.push_back(tmp);
            return ;
        }
        for(int i=0; i<nums.size();i++){
            if(visited[i])
                continue;
            visited[i] = 1;
            tmp.push_back(nums[i]);
            Permutation(res,nums, visited, tmp,index+1);
            visited[i] = 0;
            tmp.pop_back();
        }
    }
};

解法2：交换

也是使用递归函数，用index来确定已经固定好的点，从index开始与后面的交换。

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int> > res;
        Permutation(res,nums, 0);
        return res;
    }
    
    void Permutation(vector<vector<int> >& res, vector<int> nums, int index){
        if(index == nums.size()-1){
            res.push_back(nums);
            return ;
        }
        for(int i=index; i<nums.size();i++){
            swap(nums[index], nums[i]);
            Permutation(res,nums, index+1);
            swap(nums[index], nums[i]);
        }
    }
};

解法3：CareerCup解法

当n=1时，数组中只有一个数a1，其全排列只有一种，即为a1
当n=2时，数组中此时有a1a2，其全排列有两种，a1a2和a2a1，那么此时我们考虑和上面那种情况的关系，我们发现，其实就是在a1的前后两个位置分别加入了a2
当n=3时，数组中有a1a2a3，此时全排列有六种，分别为a1a2a3, a1a3a2, a2a1a3, a2a3a1, a3a1a2, 和 a3a2a1。那么根据上面的结论，实际上是在a1a2和a2a1的基础上在不同的位置上加入a3而得到的。
_ a1 _ a2 _ : a3a1a2, a1a3a2, a1a2a3
_ a2 _ a1 _ : a3a2a1, a2a3a1, a2a1a3

    vector<vector<int> > permute(vector<int>& nums) {
        if(nums.empty())
            return vector<vector<int> > (1, vector<int>{});
        int first = nums[0];
        nums.erase(nums.begin());
        vector<vector<int> > res;
        vector<vector<int> > tmp = permute(nums);
        for(int i=0;i<tmp.size();i++){
            for(int j=0;j<=tmp[i].size();j++){
                tmp[i].insert(tmp[i].begin()+j, first);
                res.push_back(tmp[i]);
                tmp[i].erase(tmp[i].begin()+j);
            }
        }
        return res;
    }

解法4：投机取巧STL

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> res;
        sort(nums.begin(), nums.end());
        res.push_back(nums);
        while (next_permutation(nums.begin(), nums.end())) {
            res.push_back(nums);
        }
        return res;
    }
};

http://www.cnblogs.com/grandyang/p/4358848.html