全排列

描述：

给定一个由不同的小写字母组成的字符串，输出这个字符串的所有全排列。 我们假设对于小写字母有'a' < 'b' < ... < 'y' < 'z'，而且给定的字符串中的字母已经按照从小到大的顺序排列。

输入：

输入只有一行，是一个由不同的小写字母组成的字符串，已知字符串的长度在1到6之间。

输出：

输出这个字符串的所有排列方式，每行一个排列。要求字母序比较小的排列在前面。字母序如下定义：

已知S = s₁s₂...s_k , T = t₁t₂...t_k，则S < T 等价于，存在p (1 <= p <= k)，使得
s₁ = t₁, s₂ = t₂, ..., s_{p - 1} = t_{p - 1}, s_p < t_p成立。

样例输入：

abc

样例输出：

abc
acb
bac
bca
cab
cba

来源：OpenJudge

法一：

思路：

全排列：从n个不同元素中任取m（m≤n）个元素，按照一定的顺序排列起来，叫做从n个不同元素中取出m个元素的一个排列。当m=n时所有的排列情况叫全排列。

举个栗子先：集合{a,b,c,d}的全排列，根据{a,b,c}的全排列会发现集合{a,b,c,d}的全排列可以用下面的排列表示

a,{b,c,d};　　{b,c,d}的全排列则可以这么表示b,{c,d};c,{b,d};d,{b,c};

b,{a,c,d}　　……　　　　　　　　　　　　

c,{a,b,d}　　……

d,{a,b,c}　　……

问题规模变小，但都是在求全排列，所以可以用递归来算。

参考代码：

/**
栗子：集合是{a,b,c,d},m=3,
swap1表示第一个swap,swap2表示第二个swap
digui({a,b,c,d},0,3)
    k=0,j=0,swap1(a,a)
调用：digui({a,b,c,d},1,3)
    k=1,j=1,swap1(b,b)
调用：digui({a,b,c,d},2,3)
    k=2,j=2,swap1(c,c)
调用：digui({a,b,c,d},3,3)
    k==m,存abcd
返回：digui({a,b,c,d},2,3)
    k=2,j=2
    swap2(c,c)
    j=3,swap1(d,c)
调用:digui({a,b,d,c},3,3)
    k==m,存<<abdc        a,b,{c,d}
——————————————————————
返回：digui({a,b,c,d},2,3)
     k=2,j=3
    swap2(d,c)
    j=4>m
返回:digui({a,b,c,d},1,3)
    k=1,j=1
    swap2(b,b)
    j=2,swap1(b,c)
调用：digui({a,c,b,d},2,3)
    j=2,k=2,swap1(b,b)
调用:digui({a,c,b,d},3,3)
    k==m,存<<acbd
返回：digui({a,c,b,d},2,3)
    j=2,k=2,
    swap2(b,b)
    j=3,swap1(d,b)
调用：digui({a,c,d,b},3,3)
    k==m,存<<acdb        a,c,{b,d}
——————————————————————
返回:digui({a,c,b,d},2,3)
    j=3,k=2
    swap2(d,b)
    j=4>m
返回:digui({a,b,c,d},1,3)
    k=1,j=1
    swap2(b,b)
    j=2,swap1(b,c)
    swap2(c,b)
    j=3,swap1(b,d)
调用：digui({a,d,c,b},2,3)
    j=2,k=2,swap1(c,c)
调用：digui({a,d,c,b},3,3)
    k==m,存<<adcb
返回：digui({a,d,c,b},2,3)
    j=2,k=2,swap1(c,c)
    swap2(c,c)
    j=3,swap1(b,c)
调用：digui({a,d,b,c},3,3)
    k==m,存<<adbc        a,d,{b,c}
————————————————————————
返回：digui({a,d,c,b},2,3)
    j=2,k=2,swap1(c,c)
    swap2(c,c)
    j=3,swap1(b,c)
    swap2(b,c)
    j=4>m
返回:digui({a,b,c,d},1,3)
    k=1,j=1
    swap2(b,b)
    j=2,swap1(b,c)
    swap2(c,b)
    j=3,swap1(b,d)
    j=4>m        以上全部是a,{b,c,d}的情况
——————————————————————————
返回:digui({a,b,c,d},0,3)
    k=0,j=0,swap1(a,a)
    swap2(a,a)
    j=1,swap(b,a)
调用:digui({b,a,c,d},1,3)

…… 和以a为首的情况一样就不一一列举了 ……
*/
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
string ss[721];
int h=0;
void digui(char *a,int k,int m);
void comp(string ss[]);
int main()
{
    string s;
    char a[7];
    int m;
    cin>>s;
    m=s.length()-1;
    for(int i=0;i<=m;i++){
        a[i]=s[i];
    }
    digui(a,0,m);
    comp(ss);//将字符串按字母序排序
    for(int i=0;i<h;i++){
        for(int j=0;j<=m;j++){
            cout<<ss[i][j];
        }
        cout<<endl;
    }
    return 0;
}
//k表示正在排列的集合的首元素
void digui(char *a,int k,int m){
//如果k==m则说明前面的集合已经全排列完了，所以直接输出，如a,b,c,{d}
if(k==m){
    ss[h++]=a;//将得到的排列存到字符串数组里
}
else{
    for(int j=k;j<=m;j++){
        //循环遍历集合内每个元素成为首元素的情况
        swap(a[j],a[k]);
        digui(a,k+1,m);//去排列以下个元素为首元素的情况
        swap(a[j],a[k]);//排列完该种情况要换回来，下面的集合好重新排列
    }
}
}
void comp(string ss[]){
    int minn;
    for(int i=0;i<h;i++){
        minn=i;
        for(int j=i+1;j<h;j++){
            if(ss[j]<ss[minn]){
                minn=j;
            }
        }
        if(minn!=i){
            swap(ss[i],ss[minn]);
        }
    }
}

 法二：（个人认为方法二简单一些）

/**
t={'A','B','C'};

dfs(0)
step=0,pos=0
i=0
ans[0]='A',
visited[2]={1,0,0},
pos=1,

dfs(1)
step=1,
i=0,i=1
ans[1]='B',
visited[2]={1,1,0},
pos=2

dfs(2)
step=2
i=0,i=1,i=2
ans[2]='C',
visited[2]={1,1,1},
pos=3

dfs(3)
step=3
print,A,B,C
i=0 to 3

//因为上面的visited都是1，所以循环结束，函数返回
dfs(2)
i=2
visited[2]={1,1,0}
pos=2

//因为上面i到了3循环完了，函数返回
dfs(1)
visited[2]={1,0,0}
pos=1;
i=2
ans[1]='C'
visited[2]={1,0,1}
pos=2

dfs(2)
step=2
i=0,i=1
ans[2]='B'
visited[2]={1,1,1}
pos=3

dfs(3)
step=3
print,ACB

…… ……

*/
#include <iostream>
#include <stdio.h>
#include <string>
using namespace std;
string t;
int visited[7];
char ans[7];
int pos=0;
int length;
void dfs(int step);
int main()
{
    cin>>t;
    length=t.size();
    dfs(0);
    return 0;
}
void dfs(int step){
    int i;
    if(step>=length){
       cout<<ans<<endl;
    }
for( i=0;i<length;i++){

    if(!visited[i]){
        ans[pos]=t[i];
        visited[i]=1;
        pos++;
        dfs(step+1);
        visited[i]=0;//回溯
        pos--;//回溯
    }

}
}