排列问题★DFS

前言

谨以此篇，送给DFS会写炸的我。
DFS是啥我也不想说了……
算了还是说说吧

DFS

思想

如果解决一个问题可以分成若干个（不确定有多少个）阶段，每一个阶段，每一个阶段要进行一次选择，用深搜解决。

模板

void dfs(int x){    if(到达边界)    {        保存解 / 输出解        return;//很重要（基于回朔的思想）    }    for(x这个阶段的选择i)        if(没有访问过i)        {            标记i已经访问过            dfs(x+1);            取消标记i        }}

排列问题

暴力排列

题目

我也不知道要叫它什么，似乎叫“生成N维向量”。我不会告诉你我不懂向量

输入K，N，输出N个有序数列，每个数列中的每个元素可以由1-K组成。
例如当K=3，N=5时，数列为：{1,1,1,1,1},{1,1,1,1,2},……,{3,3,3,3,3}

代码

暴力DFS：

#include<cstdio>#define MAXN 6int Ans[MAXN+5];int K,N;void dfs(int x){    if(x==N)    {        printf("%d",Ans[0]);        for(int i=1;i<N;i++)            printf(" %d",Ans[i]);        putchar('\n');        return;    }    for(int i=1;i<=K;i++)    {        Ans[x]=i;//不需要判重        dfs(x+1);    }}int main(){    scanf("%d%d",&K,&N);    dfs(0);}

全排列

题目

输入N，按字典序输出1 2 … N的全排列。

分析

比暴力多一个判重，因为1 2 … N的全排列没有重复元素。
两种判重方式：

• 不是Ans存了答案吗，在选择i之前在Ans中找一遍有没有i，没有才继续
• 用vis[i]表示i是否用过，递归前标记i，递归结束后取消标记

或许你知道第二种方法快得多，但是我们要试试。

代码

//两种方法的比较#include<cstdio>#include<ctime>#define MAXN 10int Ans[MAXN+5];int N,cnt1,cnt2;bool vis[MAXN+5];bool check(int x,int k)//暴力check{    for(int i=0;i<x;i++)        if(Ans[i]==k)            return 0;    return 1;}void dfs1(int x){    if(x==N)    {        //输出解（为了不计算输出的时间，把它注释掉，改为统计解的个数）        //printf("%d",Ans[0]);        //for(int i=1;i<N;i++)        //  printf(" %d",Ans[i]);        //putchar('\n');        ++cnt1;        return;    }    for(int i=1;i<=N;i++)        if(check(x,i))        {            Ans[x]=i;            dfs1(x+1);        }}void dfs2(int x){    if(x==N)    {        //输出解（为了不计算输出的时间，把它注释掉，改为统计解的个数）        //printf("%d",Ans[0]);        //for(int i=1;i<N;i++)        //  printf(" %d",Ans[i]);        //putchar('\n');        ++cnt2;        return;    }    for(int i=1;i<=N;i++)        if(!vis[i])//标记check        {            vis[i]=1;            Ans[x]=i;            dfs2(x+1);            vis[i]=0;        }}int main(){    scanf("%d",&N);    double t1,t2;    t1=clock();    dfs1(0);    t2=clock();    printf("Time (check) : %.4lf S\n",(t2-t1)/1000);    t1=clock();    dfs2(0);    t2=clock();    printf("Time (vis) : %.4lf S\n",(t2-t1)/1000);    printf("%d %d\n",cnt1,cnt2);}

时间复杂度

第一种方法：Θ(N⋅N!)，N为判重，N!为DFS；
第二种方法：
你或许会觉得它是Θ(N!)，事实上if判断需要时间，所以不止Θ(N!)，所以很可能会超时，怎么优化它呢？下面就讲。

基于交换的全排列

思想

事实上，排列就是通过不断的交换而来的，所以：

1. 将Ans数组赋成1,2,…,N
2. 递归参数x：每次将i从x枚举到N
3. 交换Ans[x]和Ans[i]
4. 递归x+1
5. 把Ans[x]和Ans[i]换回来

于是，这样就有了时间复杂度为Θ(N!)的求全排列算法了。

代码

//交换法求全排列#include<cstdio>#include<algorithm>using namespace std;#define MAXN 10int N,tot;int Ans[MAXN+5];void dfs(int x){    if(x==N)    {        tot++;        printf("%d",Ans[0]);        for(int i=1;i<N;i++)            printf(" %d",Ans[i]);        putchar('\n');        return;    }    for(int i=x;i<N;i++)    {        swap(Ans[x],Ans[i]);        dfs(x+1);        swap(Ans[x],Ans[i]);    }}int main(){    scanf("%d",&N);    for(int i=0;i<N;i++)        Ans[i]=i+1;    dfs(0);    printf("%d",tot);}

有重复元素的全排列

题目

输入一个长度不大于10的正整数数列（每个数不超过30），不重复地输出它的全排列
例如：1 2 2
输出：
1 2 2
2 1 2
2 2 1

分析

法一

分析

不重复？很好办，判重就好了：在输出Ans前判断Ans有没有输出过嘛。
将Ans（数组）映射成一个数，从而通过vis判断，大概为这样：

bool check(){    for(int i=1;i<=N;i++)        sum=(sum*10+Ans[i])%MOD;    if(!vis[sum]) return 1;    return 0;}

代码

没有写(*/ω╲*)

法二

分析

如果这个数列排序过了，那么相同元素就是挨在一起的，显然，如果下一个元素和上一个相同，显然就可以不用考虑了，所以在函数中用Last记录上一个元素即可。

代码

//没有重复的排列 法1#include<cstdio>#include<algorithm>using namespace std;#define MAXN 10int N;int A[MAXN+5],Ans[MAXN+5];bool vis[MAXN+5];void dfs(int x){    if(x>N)    {        printf("%d",Ans[1]);        for(int i=2;i<=N;i++)            printf(" %d",Ans[i]);        putchar('\n');        return;    }    int Last=-1;//没有-1    for(int i=1;i<=N;i++)        if(A[i]!=Last&&!vis[i])        {            vis[i]=1;//判重还是需要的            Last=A[i];            Ans[x]=A[i];            dfs(x+1);            vis[i]=0;        }}int main(){    scanf("%d",&N);    for(int i=1;i<=N;i++)        scanf("%d",&A[i]);    sort(A+1,A+N+1);//注意sort    dfs(1);}

法三

分析

基于桶的思想，记录每个元素i出现的次数cnt[i]，如果cnt[i]不为0就可以继续，每次dfs前cnt[i]–，dfs完了后cnt[i]++。

因为每次循环是枚举的元素类型，所以每次循环中，每种元素只会被选一次，这样也可以达到判重的目的。

代码

//没有重复的排列 法2#include<cstdio>#define MAXN 10#define MAXV 30//最大元素不超过30int N;int Ans[MAXN+5];int cnt[MAXV+5];void dfs(int x){    if(x>N)    {        printf("%d",Ans[1]);        for(int i=2;i<=N;i++)            printf(" %d",Ans[i]);        putchar('\n');        return;    }    for(int i=1;i<=MAXV;i++)        if(cnt[i])        {            cnt[i]--;            Ans[x]=i;            dfs(x+1);            cnt[i]++;        }}int main(){    scanf("%d",&N);    for(int i=1;i<=N;i++)    {        int x;        scanf("%d",&x);        cnt[x]++;//初始化    }    dfs(1);}

枚举子集

题目

输入一个字符串，输出它的所有子集。
例如：ABC
输出：
{ }
{ C }
{ B }
{ BC }
{ A }
{ AC }
{ AB }
（顺序无所谓）

分析

位向量法

分析

显然，对于每个元素，只有选或不选两种情况，标记了递归即可。

代码

//枚举子集 法1（位向量法）#include<cstdio>#include<cstring>#include<algorithm>using namespace std;#define MAXN 10int N;char s[MAXN+5];bool vis[MAXN+5];void dfs(int x){    if(x==N+1)    {        printf("{ ");        for(int i=1;i<=N;i++)            if(vis[i])                putchar(s[i]);        printf(" }\n");        return;    }    vis[x]=0;//似乎这个清零没什么用    dfs(x+1);    vis[x]=1;//vis[x]=1表示x被选了    dfs(x+1);    vis[x]=0;}int main(){    scanf("%s",s+1);    N=strlen(s+1);    dfs(1);}

时间复杂度

Θ(2N)

增量构造法

分析

换一种思路：每次从当前元素后面选择一个元素，每次一进入递归就输出Ans。

从代码角度讲：
递归参数x：
输出Ans
次i从x枚举到N，Ans记录解，dfs(i)

发现这个递归不需要边界：当x到了N+1是自然不会进入循环

或许这是常用的方法。

代码

#include<cstdio>#include<cstring>#define MAXN 10int N;char Ans[MAXN+5];char s[MAXN+5];void dfs(int x,int l){    printf("{ %s }\n",Ans);    for(int i=x;i<=N;i++)    {        Ans[l]=s[i];        dfs(i+1,l+1);        Ans[l]=0;//注意清零    }}int main(){    scanf("%s",s+1);    N=strlen(s+1);    dfs(1,0);}

时间复杂度

理论上来说是Θ(N!)

二进制法

分析

发现位向量法中的vis数组事实上是一个01串。
如果一共有5个字符，那么vis必然会这样变化（顺序不一定）：
00000
00001
00010
00011
……
11100
11101
11110
11111

依次枚举这些二进制数，然后以vis的方式输出不就可以了吗？

关于C++二进制运算

首先，我们知道电脑会用二进制进行运算，而C++就有二进制运算符。

我们先要知道：
与即and，或即or
在C++中，与是逻辑运算符&&，或是逻辑运算符||

• 1 与 1 = 1
• 1 与 0 = 0
• 0 与 0 = 0
• 1 或 1 = 1
• 1 或 0 = 1
• 0 或 0 = 0

这里列举一些：

符号 名称 计算方式 举例 实际应用 k<<x 左移运算 将k的二进制数码向左移n位，在最右端补0 010112<<110=101102 计算k⋅2n k>>x 右移运算 将k的二进制数码向右移n位，最右端消失 010112>>110=001012 计算k⋅2−n a&b 按位与 将a和b的二进制数码按位进行与运算 010112 & 110012=010012 a & 1可以得到a二进制的最后一位（奇偶性）

懒得打了，其他的自己上网查吧。

继续分析

发现当vis中全是1时，对应的十进制数是2N−1。
例如N=5时：
111112=(25−1)10
然后就可以这样计算：Max=(1<<N)-1，随时记得打括号，不然这个优先级可以把你搞疯。

怎么获取一个二进制数的（倒数）第i位？
a & 1可以得到a的二进制最后一位，那么，把这个1放在它二进制的（倒数）第i位就可以得到a二进制的（倒数）第i位了嘛。

例如：
11010 & 00001=00000
如果把后面那个数的1放在倒数第2位：
11010 & 00010=00010
再如果，把1放在倒数第4位：
11010 & 01000=01000

但是得到的不是单独的那一位，只是把其他位置上的数码都置为了0，当只剩下（倒数）第i位时，直接判断这个数是否为0就是（倒数）第i位是否为0了。

代码

#include<cstdio>#include<cstring>#define MAXN 10char s[MAXN+5];int N;int main(){    scanf("%s",s+1);    N=strlen(s+1);    int Max=(1<<N)-1;    for(int i=0;i<=Max;i++,putchar('\n'))        for(int j=0;j<N;j++)            if(i&(1<<j))                putchar(s[j+1]);//注意我是从1开始的，而1左移的位数是从0开始的}

时间复杂度

理论复杂度为Θ(N!)（里面的循环实际上是在输出，而前两种方法是没有计算输出时间的，所以这个复杂度我没有写Θ(N⋅N!)），但是由于二进制运算很快，这个的代码复杂度也不大，所以实际运行应为最快的方法。

后记

洋洋洒洒写了5000多字，算是对深搜的一个再认识吧，希望以后能不在这上面出现crash，总的来说还是理解得比较透彻的啦(╯▽╰)……