枚举排列

1.生成1-n的排列

递归生成，每一次递归选出当前位置的数，若之前选过则不再选

代码：

#include <iostream>
#include <cstdio>
using namespace std;
void print_permutation(int *A, int n, int cur)
{
    if(cur == n)
    {
        for(int i = 0; i < n; i++)
        printf("%d%c", A[i], (i == n - 1 ? '
' : ' '));
        return;
    }
    for(int i = 1; i <= n; i++)
    {
        int ok = 1;
        for(int j = 0; j < cur; j++)
            if(A[j] == i) ok = 0;
        if(ok)
        {
            A[cur] = i;
            print_permutation(A, n, cur + 1);
        }
    }
}
int main()
{
    int n;
    int *A;
    while(cin >> n)
    {
        A = new int[n];
        print_permutation(A, n, 0);
    }
    return 0;
}

 2.给定一个数组P，输出P元素的全排列

递归生成，类似于1-n排列，每一次递归查找之前的数是否出现，但由于数组内可能会有重复的数字，所以是否出现的检测办法是查看当前数组与原始数组中该数字出现的次数是否相同，还有一个比较难理解的大坑，，输入1， 1， 1，会输出27个1 1 1；原因是在选择数字的时候，哪怕这个数字已经出现在已得到的数组中，他也可能被选中。比如：数组{1（0）， 1（1）， 1（2）}， 括号里的是下标，第一次递归选择的是1（0）， 到第二个递归，由于是从i= 0开始查找，那么第二次递归也可能选择1（0）， 到最后就可能出现{1（0）， 1（0）， 1（0）}这种数列的存在，于是就会打出27次答案，就算i不同不选取，事实上{1（0）,1（1）,1（2）}与{1（2）,1（1）,1（0）}实际上也是属于一种，那么实现的方法就是，现将数组P排序，那么相同数字就会出现在相邻的位置，在每次选择的时候每种数字只需要考虑一次就够了，如果P[i] == P[i-1],就直接跳过不考虑就好了（i != 0）,

实现代码：

#include <iostream>
#include <cstdio>
using namespace std;
void print_permutation(int *A, int *P, int n, int cur)
{
    if(cur == n)
    {
        for(int i = 0; i < n; i++)
        printf("%d%c", A[i], (i == n - 1 ? '
' : ' '));
        return;
    }
    for(int i = 0; i < n; i++)
    {
        if(!i || P[i] != P[i-1])
        {
            int r1 = 0, r2 = 0;
            for(int j = 0; j < n; j++)
                if(P[j] == P[i]) r1++;
            for(int j = 0; j < cur; j++)
                if(A[j] == P[i]) r2++;
            if(r1 > r2)
            {
                A[cur] = P[i];
                print_permutation(A, P, n, cur + 1);
            }
        }

    }
}
int main()
{
    int n;
    int *A;
    int *P;
    while(cin >> n)
    {
        A = new int[n];
        P = new int[n];
        for(int i = 0; i < n; i++)
            cin >> P[i];
        print_permutation(A, P, n, 0);
    }
    return 0;
}

 3.next_permutation

c++<algorithm>里的一个函数，把当前数组改成此数组的下一个字典序排列，如果当前数组不存在下一个排列，则返回false。比如A[] = {1,3,5,4,2}的下一个排列是{1,4,2,3,5}，根据该函数的实现原理  ，我自己写了一个函数（功能没有库函数里那么强大，不过比较简单的还是能应付的，主要给自己理解用 ）

#include <iostream>
#include <cstdio>
using namespace std;
void swap(int &a, int &b)
{
    int c = a;
     a = b;
      b = c;
}

bool next_permutation(int *A, int n)
{
    if(n == 1)return false;
    int i = n - 2;
    int j = n - 1;
    while(i >= 0 && A[i] >= A[i+1])i--;
    if(i == -1)return false;
    while(A[i] >= A[j])j--;
    swap(A[i], A[j]);
    int k1 = i + 1;
    int k2 = n - 1;
    for(; k1 < k1 + (k2 - k1) / 2; k1++, k2--)
        swap(A[k1], A[k2]);
    return true;
}
int main()
{
    int n;
    while(cin >> n)
    {
        int *A = new int[n];
        for(int i = 0; i < n; i++)
            cin >> A[i];
        do
        {
            for(int i = 0; i < n; i++)
                printf("%d%c", A[i], (i == n-1 ? '
' : ' '));
        }while(next_permutation(A, n));
    }
    return 0;
}