填一下大一没好好学习的遗留坑。
其实全排列问题是个老生常谈的问题了，大一接触到的时候就知道是用递归实现，但是由于没好好学习，对其理解一直不深刻。能看出来代码是正确的，但是不理解为什么，代码也没办法自己写出来。（也是因为之前第二课堂学长给的代码意义不明）
在看了一名学长的博客之后，现在回过头来终于是弄明白了全排列的原理，所以现在写全排列也算是清晰了很多。
首先是全排列的思路，总的来说就是递归+回溯的过程：
1、先确定好当前的元素，然后分析后面的元素
2、对于后面的元素，我们也是先确定好当前的元素，再分析后面的元素。很显然这就是1的步骤，所以这就是递归了。
3、递归结束后需要回溯，由于当前元素已经确定的所有情况都已经处理完了，所以我们把当前元素的确定状态解除。在其余元素中选择当前元素，上一个元素放到后面去。
这就是全排列的大体思路。在实际写的过程中基本遇到下面两种，一是对于字典序要求不严的，这里我们的代码大致如下：
#include<stdio.h>
#include<string.h>
void f(char *a, int k)
{
int i;
char tmp;
//当一次排列的过程结束时，输出当前字符串，并且回溯
if(k == strlen(a))
{
puts(a);
return;
}
for(i = k; i < strlen(a); i++) //k是处理到第几个字符，该字符与后面的交换
{
//1.将当前元素之后的所有元素（包括其自己）交换位置
tmp = a[k]; a[k] = a[i]; a[i] = tmp; //swap(a[k],a[i])
//2.上一个元素已经确定好位置了，我们对下一位及以后的元素进行同样处理
f(a, k+1);
//3.回溯到上一轮，然后交换回到1之前的状态，然后与1中交换的下一个元素进行交换
tmp = a[k]; a[k] = a[i]; a[i] = tmp; //swap(a[k],a[i])
}
}
int main()
{
char a[101];
scanf("%s",a);
f(a, 0);
return 0;
}
但是这种处理方式不能处理按照字典序的排序输出，如果我们输入1234，会得到如下输出：
1234
1243
1324
1342
1432
1423
2134
2143
2314
2341
2431
2413
3214
3241
3124
3142
3412
3421
4231
4213
4321
4312
4132
4123我们看到1432在1423之前，这是因为这是2与4交换位置后的情况，所以程序会先输出1432。
如果我们要按照字典序输出，就需要通过类似DFS的思路：
1、首先确定当前元素，然后压入栈中。这里我们用到的是一个类似于栈的数据结构，每次选择好元素后将其压入栈中。不过最后我们会遍历数组输出，而且省略了出栈。严格说来并不完全与栈相同。同时标记该元素已经出现过。然后确定下一个元素。
2、在未出现过的元素中确定一个元素压入栈中，这里也是递归的思想。
3、回溯到1之前的情况，即释放当前元素，将其标记未未使用过。然后从后面的元素中确定当前元素。代码如下：
#include<stdio.h>
#define MAX 10
char stack[MAX+1]={0}; //以字符串的形式存放生成的全排列数
int used[MAX]={0};
int N;
void allrank(int m,int n); //全排列数生成函数
int main()
{
printf("Input a number N(1<=N<=10):");
scanf("%d",&N);
allrank(0,N);
return 0;
}
void allrank(int m,int n)
{
int i=0;
//n是剩余的没被标记（使用）的数，如果n=0，意味着数字被用完了，输出并且回溯
if(n==0)
{
stack[N+1]='\0';
puts(stack);
return;
}
for(i=1;i<=N;i++)
{
if(used[i]==0)
{
used[i]=1; //数字i被标记为已使用
stack[m]='0'+i;
allrank(m+1,n-1); //进入了另一个函数
used[i]=0; //数字i被释放 （回溯）
}
}
}
首先我们把1号元素确定为1，然后从234中进行全排列。
我们把2号元素设定为2，然后从34中进行全排列。
我们把3号元素设定为3，从4中进行全排列。得到1234.
然后回溯，把3号元素设定为4，得到1243。
再回溯，就需要把2号元素改为3，然后对24全排列……
最终得到这样的
1234
1243
1324
1342
1423
1432
2134
2143
2314
2341
2413
2431
3124
3142
3214
3241
3412
3421
4123
4132
4213
4231
4312
4321结果，这正是我们想要的字典序。因为每次确定元素时，我们总是最小的元素优先安排上这个位置，把所有排列完成后，然后再把后面的元素安排上这个位置。
总的来说，这就是递归+回溯的全过程。
如果你已经理解了，那么来看看其他的全排列吧。
重复数全排列
【问题描述】
输入一个字符串，字符串由字母、数字组成，可能包含重复的字符。生成这些字符的不重复的全排列，并将结果打印到标准输出上。
【输入形式】
从标准输入上读入一个由字母、数字组成的字符串，字符串的长度小于100，其中包含重复的字符。
【输出形式】
向标准输出印结果。 每个排列占1行，各字符之间无空格分隔，每行由换行符结束。各行之间不必排序，但同一个排列不得重复输出。
【输入样例】
AABB
【输出样例】
AABB
ABAB
ABBA
BABA
BAAB
BBAA
【时间限制】
20s
【空间限制】
65536KB这题对于排列顺序没有要求，而且是对于字符串的排列，所以是使用第一种的思路。然而出现了重复数，所以大致思路是有的情况下不能继续递归调用了。
我一开始的思路是每次实现一个排列后记录下来。之后如果一次交换后出现了已出现过的序列，那么就不必再递归，直接跳过这次交换。然而20s的运行时间还是超时了= =所以去网上搜了思路
我的思路之所以超时，还是因为仅仅做到排除相同情况的序列，而不是想办法规避。我们分析如下一种情况，当前序列为
AB132768B90。当A首先与第一个B交换时，我们得到序列BA132768B90。然后我们对于后面的部分A132768B90进行全排列。当回溯后继续交换，如果A与第二个B交换，会得到BB132768A90，而后面的序列全排列之后与A132768B90的全排列完全相同。所以这次交换完全可以跳过。
也就是说，在判断时，如果一个字符在之前出现过，就不需要进行这次交换，更不需要递归调用了。用编程语言描述：第i个字符与第j个字符交换时，如果[i,j)中没有与第j个数相等的字符则需要交换，如果有则不需要交换。
代码如下，我们使用isSwap来判断是否需要交换：
#include<stdio.h>
#include<string.h>
#include<stdbool.h>
#define MAXNUM 101
void fullsort(char s[], int k);
bool isSwap(char s[], int begin, int end);
int main()
{
char s[MAXNUM];
scanf("%s", s);
fullsort(s, 0);
return 0;
}
void fullsort(char s[], int k)
{
int i, temp;
if (k == strlen(s))
{
puts(s);
return;
}
for (i = k; i < strlen(s); i++)
{
if(isSwap(s, k, i))
{
temp = s[k]; s[k] = s[i]; s[i] = temp;
fullsort(s, k + 1);
temp = s[k]; s[k] = s[i]; s[i] = temp;
}
}
}
bool isSwap(char s[], int begin, int end)
{
int i;
for(i = begin; i < end; i++)
if(s[i] == s[end])
return false;
return true;
}
这个思路是在交换前就判断需不需要交换，因此避免了多余的递归与回溯，大大节省了运行时间。经检验运行时间都没有超过1s的。（为什么我想不出来这么好的方法呢）
选排列
【问题描述】
求从n个自然数(1-n)中选取m个数的所有的排列形式，即求P（n，m）的所有的排列形式，且按升序排列。
【输入形式】
标准输入。输入只有一行，包括两个整数n和m，其中0<n,m<=9，二者之间以一个空白符分隔。
【输出形式】
在标准输出上输出有若干行，每一行都是符合题意的一种排列形式，每个元素间用一个空格分隔，并按升序排列。
【输入样例】
3 2
【输出样例】
1 2
1 3
2 1
2 3
3 1
3 2
【时间限制】
2s
【空间限制】
65536KB全排列的变体。（不如说全排列是选排列的特殊情况）
不难，也是DFS，全排列是全部使用（即栈中元素到达n个）才输出，而选排列则是栈中元素到了m个就需要输出并回溯了。
#include<stdio.h>
#define MAXNUM 10
int used[MAXNUM] = { 0 };
int stack[MAXNUM];
int m, n;
void permutation(int a);
int main()
{
scanf("%d%d", &n, &m);
permutation(0);
return 0;
}
void permutation(int a)
{
int i;
if (a == m)
{
for (i = 0; i < m; i++)
printf("%d ", stack[i]);
printf("\n");
return;
}
for (i = 1; i <= n; i++)
{
if (used[i] == 0)
{
stack[a] = i;
used[i] = 1;
permutation(a + 1);
used[i] = 0;
}
}
}
代码里的a记录的基本就是栈中元素的个数。
组合
【问题描述】
求n个自然数(1-n)的所有m-组合，即C（n，m）的所有不可重复的组合形式。
【输入形式】
标准输入。输入只有一行，包括两个整数n和m，其中0<n<=20，0<m<=n，二者之间以一个空白符分隔。 输入内容可以保证在算法得当情况下，规定时间内可以完成。
【输出形式】
在标准输出上输出有若干行，每一行都是符合题意的一种排列形式，每个元素间用一个空格分隔，并按升序排列。
【输入样例】
3 2
【输出样例】
1 2
1 3
2 3
【时间限制】
2s
【空间限制】
65536KB与选排列类似，不过要避免重复选择。思路也很简单。每次出现一个元素被选择后，确定下面的元素就得从该元素后面寻找选择。所以用一个start来表示从哪个元素开始遍历。
#include<stdio.h>
#define MAXNUM 22
int used[MAXNUM] = { 0 };
int stack[MAXNUM];
int m, n;
void choose(int a, int start);
int main()
{
scanf("%d%d", &n, &m);
choose(0, 1);
return 0;
}
void choose(int a, int start)
{
int i;
if (a == m)
{
for (i = 0; i < m; i++)
printf("%d ", stack[i]);
printf("\n");
return;
}
for (i = start; i <= n; i++)
{
if (used[i] == 0)
{
stack[a] = i;
used[i] = 1;
choose(a + 1, i + 1);
used[i] = 0;
}
}
}
错位全排列
【题目描述】
输出第 k 大的 1∼n 的全错位排列。
全错位排列：对于数字 1∼n 的一个排列 p1,p2,…,pn，如果对 ∀i∈[1,n] ，都有 pi≠i，那么称它为全错位排列。
第 k 大：把全错位排列按照字典序从大到小排序之后的第 k 个。
【输入】
第一个数为数据组数 T(1≤T≤20) 。
接下来 T 行，每行两个空格隔开的正整数 n,k(2≤n≤9)。保证 k 合法。
【输出】
对于每组数据，输出一行，n 个空格隔开的整数。表示第 k 大的全错位排列
【输入样例】
2
2 1
3 1
【输出样例】
2 1
3 1 2
【题目来源】:BUAAOJ 1079 ruaaaaa
麻烦一点的可能是处理第k大，首先我们用一个index来表示这是第几大的。其次由于是字典序大的在前面，所以我们从后往前遍历，这样每次都是字典序大的在前面出现。
除此之外，全排列的判断仅仅是多了一个p[i] != i而已，在递归时判断一下就好了。
#include<stdio.h>
#define MAXNUM 10
int used[MAXNUM] = {0};
int stack[MAXNUM];
int m, n, index;
void allrank(int number)
{
int i;
if(number == m)
{
index ++;
if(index == n)
{
for(i = 0; i < m; i++)
printf("%d ", stack[i]);
putchar('\n');
}
}
for(i = m; i >= 1; i--)
{
if(used[i] == 0 && number + 1 != i)
{
used[i] = 1;
stack[number] = i;
allrank(number + 1);
used[i] = 0;
}
}
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
index = 0;
scanf("%d%d",&m,&n);
allrank(0);
}
return 0;
}说白了，只要能理解开始的两种全排列基本情况，后面的变体那都不是事。
扫一扫
277
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
