前言
谨以此篇,送给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);
}
时间复杂度
第一种方法:
Θ(N⋅N!)
,N为判重,N!为DFS;
第二种方法:
你或许会觉得它是
Θ(N!)
,事实上if判断需要时间,所以不止
Θ(N!)
,所以很可能会超时,怎么优化它呢?下面就讲。
基于交换的全排列
思想
事实上,排列就是通过不断的交换而来的,所以:
- 将Ans数组赋成1,2,…,N
- 递归参数x:每次将i从x枚举到N
- 交换Ans[x]和Ans[i]
- 递归x+1
- 把Ans[x]和Ans[i]换回来
于是,这样就有了时间复杂度为 Θ(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);
}
时间复杂度
Θ(2N)
增量构造法
分析
换一种思路:每次从当前元素后面选择一个元素,每次一进入递归就输出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);
}
时间复杂度
理论上来说是 Θ(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
& |
懒得打了,其他的自己上网查吧。
继续分析
发现当vis中全是1时,对应的十进制数是
例如N=5时:
111112=(25−1)10
然后就可以这样计算:Max=(1<<N)-1
,随时记得打括号,不然这个优先级可以把你搞疯。
怎么获取一个二进制数的(倒数)第
i
位?
例如:
11010
&
00001=00000
如果把后面那个数的
1
放在倒数第2位:
再如果,把
1
放在倒数第4位:
但是得到的不是单独的那一位,只是把其他位置上的数码都置为了0,当只剩下(倒数)第
i
位时,直接判断这个数是否为
代码
#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开始的
}
时间复杂度
理论复杂度为 Θ(N!) (里面的循环实际上是在输出,而前两种方法是没有计算输出时间的,所以这个复杂度我没有写 Θ(N⋅N!) ),但是由于二进制运算很快,这个的代码复杂度也不大,所以实际运行应为最快的方法。
后记
洋洋洒洒写了5000多字,算是对深搜的一个再认识吧,希望以后能不在这上面出现crash,总的来说还是理解得比较透彻的啦(╯▽╰)……