LeetCode - Permutations

最新推荐文章于 2019-03-30 13:40:00 发布

real_lisa

最新推荐文章于 2019-03-30 13:40:00 发布

阅读量299

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode 文章标签： Permutation recursion

本文链接：https://blog.youkuaiyun.com/real_lisa/article/details/82943194

LeetCode 专栏收录该内容

180 篇文章

订阅专栏

本文深入解析了四种不同的排列算法：DFS递归、交换递归、插入递归及迭代方法。通过具体的代码示例，详细解释了每种算法的工作原理及其在解决排列问题中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

解法一：DFS recursion

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> res;
        vector<int> out;
        vector<int> visited(nums.size(), 0);
        gen(nums, 0, visited, out, res);
        return res;
    }
    void gen(vector<int>& nums, int pos, vector<int>& visited, vector<int>& out, vector<vector<int>>& res){
        if(pos == nums.size()) {
            res.push_back(out);
        }
        else{
            for(int i=0;i<nums.size();i++){
                if(visited[i]==0){
                    visited[i] = 1;
                    out.push_back(nums[i]);
                    gen(nums, pos+1, visited, out, res);
                    out.pop_back();
                    visited[i] = 0;
                }
            }
        }
    }
};

recursion function

1. vector<int>& num -- original input

2. int pos -- when to stop

3. vector<bool>& visited -- if visited

4. vector<int>& out -- generating the solution

5. vector<vector<int>>& res -- collect the solutions

解法二：swap recursion

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

理解：排序就是换位置啊～

？为什么这能形成一个有序的暴力解法

解法三：recursion

class Solution {
public:
    vector<vector<int> > permute(vector<int> &num) {
        int n = num.size();
        if(n==0) return {{}};
        vector<vector<int>> res;
        int first = num[0];
        num.erase(num.begin());
        vector<vector<int>> t = permute(num);
        for(auto& a: t){
            for(int i=0;i<n;i++){
                a.insert(a.begin()+i, first);
                res.push_back(a);
                a.erase(a.begin()+i);
            }
        }
        return res;
    }
};

理解：在前一种情况下，不同位置插入下一个元素形成不同的排列。

解法四：思路同上，iteration

class Solution {
public:
    vector<vector<int> > permute(vector<int> &num) {
        int n = num.size();
        if(n==0) return {{}};
        vector<vector<int>> res{{}};
        for(auto& a: num){
            if(res[0].empty()) {
                res[0].push_back(a);
                continue;
            }
            int s = res.size();
            for(int j=0;j<s;j++){
                vector<int> b = res[j];
                for(int i=0;i<b.size()+1;i++){
                    b.insert(b.begin()+i, a);
                    res.push_back(b);
                    b.erase(b.begin()+i);
                }
            }
            res.erase(res.begin(), res.begin()+s);
        }
        return res;
    }
};