全排列生成 Permutations_全排列生成不同的permutation-CSDN博客

本文链接：https://blog.csdn.net/ojshilu/article/details/15827291

本文介绍了三种不同的全排列算法实现思路，包括通过交换得到的全排列（适用于无重复元素的情况）、通过插入操作实现的全排列以及处理包含重复元素情况的全排列算法。文中提供了详细的代码示例，帮助读者理解每种方法的原理及其应用。

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

题目：Given a collection of 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].

思路一（无重复元素）：这是通过交换得到的全排列。

class Solution {
public:
    vector<vector<int> > permute(vector<int> &num) {
        vector<vector<int> > v;
        ProduceArray(num, 0, v);
        return v;
    }

void ProduceArray(vector<int> data, int index, vector<vector<int> > &v)  
{  
	int n = data.size();
    if(index == n)  
    {  
        v.push_back(data);
        return;
    }  
    for(int i=index;i < n;i++)  
    {  
        swap(data[i], data[index]);  
        ProduceArray(data, index+1, v);  
        swap(data[i], data[index]);  
    }
}
};

注意：这种方法的缺点是如果序列中有重复元素，得到的排列也是有重复的。

思路二：第一种方法的思路是交换，第二种方法的思路就是插入。首先拿出原序列的第一个元素，然后将其插入到剩余序列中，有n种插入方法（得到的序列个数是原来的n倍）。递归地，剩余序列也可以这么做而得到。这也可以看作是一种分治策略，即把规模为N的原问题分解为规模为1的问题和规模为N的问题。

代码：

#include <iostream>
#include <string>
#include <vector>
using namespace std;

string insertCharAt(const string &word, char c, int i)
{
    if(i<0 || i > word.size())
        return word;
    string left = word.substr(0, i);
    string right = word.substr(i);
    
    return left + c + right;
}


vector<string> genPermutation(const string &s)
{
    vector<string> re;
    if(s.size() == 1)
    {
        re.push_back(s);
        return re;
    }
    char first = s[0];
    string rest = s.substr(1);
    vector<string> restwords = genPermutation(rest);
    
    vector<string>::iterator it = restwords.begin();
    for( ;it != restwords.end();it++)
    {
        for(int i=0;i<=(*it).size();i++)
        {
            re.push_back(insertCharAt((*it), first, i));
        }
    }
    return re;
}


int main(int argc, const char * argv[])
{
    string s = "abc";
    vector<string> permutation = genPermutation(s);
    cout<<permutation.size()<<endl;
    vector<string>::iterator it = permutation.begin();
    for(; it != permutation.end();it++)
        cout<<(*it)<<endl;
    return 0;
}

思路三（有重复元素）：先利用hash给每种不同的数做计数统计，然后用backtrack方法。需要辅助空间。

class Solution {
public:
    vector<vector<int> > permuteUnique(vector<int> &num) {
        vector<vector<int> > v;
        int n = num.size();
        if(n == 0)
            return v;
            
        map<int, int> m;
        for(int i=0;i<n;i++)
            if(m.find(num[i]) == m.end())
                m[num[i]] = 1;
            else
                m[num[i]]++;
        
        vector<int> now;
        backtrack(m, v, num, n, now, 0);
        return v;
    }
    
    void backtrack(map<int, int> &m, vector<vector<int> > &v, vector<int> &num, int n, vector<int> now, int idx)
    {
        if(idx == n)
        {
            v.push_back(now);
            return;
        }
        map<int, int>::iterator it = m.begin();
        for(;it != m.end(); it++)
        {
            if((*it).second > 0)
            {
                (*it).second--;
                now.push_back((*it).first);
                backtrack(m, v, num, n, now, idx+1);
                (*it).second++;
                now.pop_back();
            }
        }
    }

};