排列问题★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 6
int 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 10
int 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);
}

时间复杂度

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

基于交换的全排列

思想

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

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

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

代码

//交换法求全排列
#include<cstdio>
#include<algorithm>
using namespace std;

#define MAXN 10
int 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 10
int 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//最大元素不超过30
int 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 10
int 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);
}

时间复杂度

$\Theta(2^N)$

增量构造法

分析

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

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

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

或许这是常用的方法。

代码

#include<cstdio>
#include<cstring>

#define MAXN 10
int 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);
}

时间复杂度

理论上来说是$\Theta(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	$01011_2<<1_{10}=10110_2$	计算$k·2^n$
k>>x	右移运算	将k的二进制数码向右移n位，最右端消失	$01011_2>>1_{10}=00101_2$	计算$k·2^{-n}$
a&b	按位与	将a和b的二进制数码按位进行与运算	$01011_2$ & $11001_2=01001_2$	$a$ & $1$可以得到$a$二进制的最后一位（奇偶性）

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

继续分析

发现当vis中全是1时，对应的十进制数是$2^N-1$。
例如N=5时：
$11111_2=(2^5-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 10
char 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开始的
}

时间复杂度

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

后记

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