bfs,dfs剪枝

转载自:https://www.cnblogs.com/fenghaoran/p/6391016.html

搜索是OI之路上,人人必会的强大算法。自古便有名言:“暴力进省队”(实际上,很多考试你打好所有暴力就可以拿到不错的分数)。

在考场上,搜索常常是与正解的对拍板子(当然有时搜索就是正解),且一般搜索都会有20~30分。

而想要写好搜索,剪枝必不可少(有时出题人不会给纯暴力分)。

what's 剪枝?

常用的搜索有Dfs和Bfs。

Bfs的剪枝通常就是判重,因为一般Bfs寻找的是步数最少,重复的话必定不会在之前的情况前产生最优解。

深搜,它的进程近似一颗树(通常叫Dfs树)。

而剪枝就是一种生动的比喻:把不会产生答案的,或不必要的枝条“剪掉”。

剪枝的关键就在于剪枝的判断:什么枝该剪,什么枝不该剪,在什么地方减。

剪枝的原则?

正确性,准确性,高效性。

常用的剪枝有:可行性剪枝、最优性剪枝、记忆化搜索、搜索顺序剪枝。

1.可行性剪枝。

如果当前条件不合法就不再继续搜索,直接return。这是非常好理解的剪枝,搜索初学者都能轻松地掌握,而且也很好想。一般的搜索都会加上。

一般格式:

dfs(int x)
{
if(x>n)return;
if(!check1(x))return;
....
return;
}

2.最优性剪枝。

           如果当前条件所创造出的答案必定比之前的答案大,那么剩下的搜索就毫无必要,甚至可以剪掉。

   我们利用某个函数估计(估值函数)出此时条件下答案的‘下界’,将它与已经推出的答案相比,如果不比当前答案小,就可以剪掉。

   一般格式:

 

long long ans=987474477434487ll;
... Dfs(int x,...)
{
	if(x... && ...){ans=....;return ...;}
	if(check2(x)>=ans)return ...;	//最优性剪枝 
	for(int i=1;...;++i)
	{
		vis[...]=1; 
		dfs(...);
		vis[...]=0;
	}
}

一般实现:在搜索取和最大值时,如果后面的全部取最大仍然不比当前答案大就可以返回。
在搜和最小时同理,可以预处理后缀最大/最小和进行快速查询。

3.记忆化搜索。

  记忆化搜索其实很像动态规划(DP)。

它的关键是:如果对于相同情况下必定答案相同,就可以把这个情况的答案值存储下来,以后再次搜索到这种情况时就可以直接调用。

还有就是不能搜出环来,不能互相依赖。

  一般格式:

long long ans=987474477434487ll;
... Dfs(int x,...)
{
	if(x... && ...){ans=....;return ...;}
	if(vis[x]!=0)return f[x];vis[x]=1;
	for(int i=1;...;++i)
	{
		vis[...]=1; 
		dfs(...);
		vis[...]=0;
		f[x]=...;
	}
}

 

4.搜索顺序剪枝

  在一些迷宫题,网格题,或者其他搜索中可以贪心的题,搜索顺序显得十分重要。我经常听见有人说(我自己也说过):“从左边搜会T,从右边搜就A了”之类的语句。

  其实在迷宫、网格类的题目中,以左上->右下为例,右下左上就明显比左上右下优秀。

  在一些推断搜索题中,从已知信息最多的地方开始搜索显然更加优秀。

  在一些题中,先搜某个值大的,再搜某个值小的(比如树的度数,产生答案的预计(A*)),速度明显会比乱搜更快。

  搜索的复杂度明显讲不清,这种剪枝自然是能加就加。

 

例题:

codevs1288 埃及分数

在古埃及,人们使用单位分数的和(形如1/a的, a是自然数)表示一切有理数。 如:2/3=1/2+1/6,但不允许2/3=1/3+1/3,因为加数中有相同的。

对于一个分数a/b,表示方法有很多种,但是哪种最好呢? 首先,加数少的比加数多的好,其次,加数个数相同的,最小的分数越大越 好。

如:

  19/45=1/3 + 1/12 + 1/180 19/45=1/3 + 1/15 + 1/45 19/45=1/3 + 1/18 + 1/30, 19/45=1/4 + 1/6 + 1/180 19/45=1/5 + 1/6 + 1/18.

最好的是最后一种,因为1/18比1/180,1/45,1/30,1/180都大。 给出a,b(0

 

Sample Input

2 3

Sample Output

2 6

 

Sample Input

19 45

Sample Output

5 6 18

下面是代码

#include    
#include    
#include    
#include    
#define LL long long int
using namespace std;
LL a,b,depth,FLAG=1,zZ[101010],Ans[101010],Maxx=10101000;
LL gcd(LL a,LL b){return b>0?gcd(b,a%b):a;}                            //辗转相除法求最大公约数 
void dfs(LL now,LL a,LL b,LL last,LL depth)
{
    if(now==depth-1)
    {
        if(a!=1)return;
        if(blast)
            {
                zZ[now+1]=b;FLAG=0;Maxx=b;
                for(LL i=1;i<=now+1;++i){Ans[i]=zZ[i];}
            }
        return;
    }
    if(a*(last+1)>=b*(depth-now) || last>Maxx || a==0)return;        //第一个是可行性剪枝,是个十字相乘式,建议移项看
    for(LL i=last+1,K=(depth-now)*b/a;i

 

(以下为非转载内容)还有另一道经典的剪枝题目:POJ 1011 Sticks • Description

给出n根木棒的长度stick[i],每根长度不超过50,已知这n根长棒原本由若木根长度相同的原始木棒分解而来。求出原始木棒的最小可能长度。

• Input

输入包含多组数据,每组数据包括两行。第一行是一个不超过64的整数,表示砍断之后共有多 少节木棍。第二行是截断以后,所得到的各节木棍的长度。在最后一组数据之后,是一个零。

• Output

为每组数据,分别输出原始⽊棒的可能最小长度,每组数据占一行。

• Sample Input

9

5 2 1 5 2 1 5 2 1

4

1 2 3 4

0

• Sample Output

6

5

这一题不算太难,但是对时间要求很苛刻,对剪枝来说是很好的题目了

下面是代码:

#include 
#include 
#include 
#include 
#include 
using namespace std;
#define mem(a, b) memset((a),(b),sizeof(a))

const int MAXN=64+3;
int N, stick[MAXN], ans;
bool used[MAXN];///第i个木棒是否已经被使用

bool dfs(int pos, int now_len, int num)///当前搜索的位置,当前组合长度,已经使用的木棒数
{
    if(num>=N && !now_len)///常数优化
        return true;
    int last=-1;
    for(int i=pos;i>=0;--i)///优先考虑大的木棒
    {
        if(used[i] || stick[i]==last)///如果根木棒已经使用过,不能再次使用。如果和上根一样,不需要再搜一遍
            continue;
        used[i]=true;
        if(now_len+stick[i]==ans)///加上当前木棒,刚好可以组成一根初始木棒
            if(dfs(N-1, 0, num+1))///从头开始重新找一组木棒
                return true;
            else last=stick[i];
        else if(now_len+stick[i]

 

你可能感兴趣的:(bfs,dfs剪枝)