搜索的优化技巧

关于搜索，计算时间复杂度是一件很闹心的事。最常见的优化技巧是剪枝（卡常），通常可以剪的地方有：

1. 已经不可行，继续搜下去一定不可能 / 该方案不可行，没有必要继续本次处理
2. 当前答案已经比以前记录的答案差，并且不可能据此搜出更优答案
3. 记忆化搜索

但是在搜索里，还有许多优化方式（太爱OI Wiki啦）

目录

一、记忆化搜索

二、双向搜索

三、启发函数与估价函数

四、迭代加深搜索

---

一、记忆化搜索

这是一个与DP相关的东西。写经典DP采药的时候如果用DFS爆搜，那么大概是：

#include<bits/stdc++.h>
using namespace std;
int n,t,ans;
int tim[100010],get[100010];
void dfs(int k,int t,int ans1)
{
	if(t<0)return;
	if(k==n+1)
	{
		ans=max(ans,ans1);
		return;
	}
	dfs(k+1,t,ans1);
	dfs(k+1,t-tim[k],ans1+get[k]);
}
int main()
{
	scanf("%d%d",&t,&n);
	for(int i=1;i<=n;i++) scanf("%d%d",&tim[i],&get[i]);
	dfs(1,t,0);
	printf("%d",ans);
	return 0;
}

超时是一定的，那么改成记忆化呢？在考虑像放前缀和一样把答案放进某个数组时，有一个问题就是要求此时的爆搜不能依赖任何外部变量（就是说传入参数一样时，得到的答案一定相同），然而原代码的ans1明显不太行。那我们可以通过返回值上的比较找到最大值。DFS部分：

int dfs(int k,int tt)
{
	if(k==n+1) return 0;
	int dfs1,dfs2=-1e9;
	dfs1=dfs(k+1,tt);
	if(tt>=tim[k]) dfs2=dfs(k+1,tt-tim[k])+get[k];
	return max(dfs1,dfs2);
}

接下来就好办了：只需用二维数组简单记录一下即可，加一句：

if(mem[k][tt]!=-1) return mem[k][tt];

二、双向搜索

双向搜索是指从前往后搜的同时从后往前搜，两个方向相遇得到的就是最优解。与之易混淆的是折半查找，详见一本通深搜练习2《最大费用》。优化时间复杂度可以从到

这是OI Wiki给的板子：

将开始结点和目标结点加入队列 q
标记开始结点为 1
标记目标结点为 2
while (队列 q 不为空)
{
  从 q.front() 扩展出新的 s 个结点

  如果 新扩展出的结点已经被其他数字标记过
    那么 表示搜索的两端碰撞
    那么 循环结束

  如果 新的 s 个结点是从开始结点扩展来的
    那么 将这个 s 个结点标记为 1 并且入队 q 

  如果 新的 s 个结点是从目标结点扩展来的
    那么 将这个 s 个结点标记为 2 并且入队 q
}

对于例题Light，正常要用哈希，但我太菜了qwq并不会写就只好偷懒用 map，我们可以进行折半搜索，分别搜索 1 到 n/2，n/2+1 到 n 的状态，如果两种状态可以互补，那么当前花费就是到达两种状态的花费之和。（来自淸梣lingdalao的题解）

#include<iostream>
#include<cstdio>
#include<map>
#include<cmath>
using namespace std;

long long v[40],twon;//twon位二进制下的点全为1
int n;
int ans=2147483647;
map<long long,int> m;

void dfs(int x,int u,long long k,int t)
{
	if(m[k])m[k]=min(m[k],t);//更新当前状态的花费
	else m[k]=t;
    
	if(m[k^twon]||k==twon)
	ans=min(ans,m[k^twon]+t);//更新答案
	
	if(x<=u)
	{
		dfs(x+1,u,k,t);//不更改当前点
		k=k^v[x];
		dfs(x+1,u,k,t+1);//更改当前点
	}
}
int main()
{
	int m;
	int i;

	cin>>n>>m;
	for(i=1;i<=m;i++)
	{
		long long a,b;
		scanf("%lld%lld",&a,&b);
		v[a]=v[a]^1<<b;//a与b建边
		v[b]=v[b]^1<<a;//b与a建边
	}
	
	for(i=1;i<=n;i++)
	{
		v[i]=v[i]^1<<i;//自身也会变化
		twon=twon^1<<i;
	}
	
	dfs(1,n/2,0,0);//meet in middle
	dfs(n/2+1,n,0,0);

	cout<<ans;
	return 0;
}

三、估价函数

估价函数（尤指深搜中的IDA*）详见《骑士精神》在题目中操作次数有明显限制是（譬如本题中小于等于15步），如果已走步数加上接下来完美的操作数已经超过限制，直接跳出。其中完美操作可能实现不了，但一定不会漏解。

#include<bits/stdc++.h>
using namespace std;
int mp[10][10];
const int goal[6][6]={
	{0,0,0,0,0,0},
	{0,1,1,1,1,1},
	{0,0,1,1,1,1},
	{0,0,0,2,1,1},
	{0,0,0,0,0,1},
	{0,0,0,0,0,0}};
int T,mx,my;
bool ok,flag;
const int go[8][2]={{1,2},{1,-2},{-1,2},{-1,-2},{2,1},{-2,1},{2,-1},{-2,-1}};
int evaluate()
{
	int cnt=0;
	for(int i=1;i<=5;i++)
		for(int j=1;j<=5;j++)
			if(mp[i][j]!=goal[i][j]) cnt++;
	return cnt;
}//如果接下来都是一步到位，就是完美操作数
bool judge(int x,int y)
{
	if(x<1||x>5||y<1||y>5) return 0;
	return 1;
}
void dfs(int dep,int maxdep,int x,int y)
{
	if(dep==maxdep&&evaluate()==0)
	{
		ok=1;
		return;
	}
	for(int i=0;i<8;i++)
	{
		int xx=x+go[i][0];
		int yy=y+go[i][1];
		if(!judge(xx,yy)) continue;
		swap(mp[xx][yy],mp[x][y]);
		int best=evaluate();
		if(best+dep<=maxdep) dfs(dep+1,maxdep,xx,yy);
		swap(mp[xx][yy],mp[x][y]);
	}
}
int main()
{
	scanf("%d",&T);
	while(T--)
	{
		ok=0,flag=0;
		for(int i=1;i<=5;i++)
		{
			for(int j=1;j<=5;j++)
			{
				char aa;
				cin>>aa;
				if(aa=='*')
				{
					mp[i][j]=2;
					mx=i,my=j;
				}
				if(aa=='0')mp[i][j]=0;
				if(aa=='1')mp[i][j]=1;
			}
		}
		if(!evaluate())
		{
			printf("0\n");
			continue;
		}
		for(int maxdep=1;maxdep<=15;maxdep++)
		{
			dfs(0,maxdep,mx,my);
			if(ok==1)
			{
				printf("%d\n",maxdep);
				flag=1;
				break;
			}
		}
		if(!flag) printf("-1\n");
	}
	return 0;
}

四、启发式函数

启发式函数的作用是基于已有的信息对搜索的每一个分支选择都做估价，进而选择分支。简单来说，启发式搜索就是对取和不取都做分析（计算性价比），从中选取更优解或删去无效解。就可以看成可行性剪枝与最优性剪枝的灵活结合（采药代码）

#include<bits/stdc++.h>
using namespace std;
int n,m,ans;
struct node
{
	int a,b;// time  value
	double f;
}ma[100010];
bool operator<(node aa,node bb) {return aa.f>bb.f;}
int f(int k,int val)
{
	int tot=0;
	for(int i=1;i+k<=n;i++)
	{
		if(val>=ma[k+i].a)
		{
			val-=ma[k+i].a;
			tot+=ma[k+i].b;
		}
		else return (int)(tot+val*ma[k+i].f);
	}
	return tot;
}//性价比排序后，可直接计算当前时间下剩余物品最大价值
void work(int k,int t,int val)
{
	ans=max(ans,val);
	if(k>n) return;
	if(f(k,t)+val>ans) work(k+1,t,val);
	if(ma[k].a<=t) work(k+1,t-ma[t].a,val+ma[k].b);
}
int main()
{
	scanf("%d%d",&m,&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d%d",&ma[i].a,&ma[i].b);
		ma[i].f=1.0*ma[i].b/ma[i].a;
	}
	sort(ma+1,ma+n+1);//按性价比排序
	work(1,m,0);
	printf("%d",ans);
	return 0;
}