搜索指南 QwQ

已于 2024-09-26 20:54:38 修改
阅读量439 收藏 22
点赞数 21
分类专栏： 算法指南 文章标签： 算法
于 2024-09-23 21:21:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hisy_qwq/article/details/142469004
版权

dfs 和 bfs

dfs

dfs，是英文名 deep-first-search 的缩写，它的思想是一搜到底，撞墙回头。这一种思想是基于递归和栈实现的，打个比方，你在迷宫里面，发现有岔路口，先向左走，走了一段时间发现是死路，退回去之后走右边。

基于 dfs，有一种术语叫做：回溯。回溯的思想是如果要走这一条路，那么就踩上去脚印，如果撞墙，回退的过程就把脚印擦掉。这一种思想避免了很多情况：比如重复走，不走可以走的路，记录答案错误等。

下面，给出 dfs 的伪代码：

void dfs(node dep){//node 为深度的类型 
	if(check(dep)){//答案撞墙了 
		change(ans);//更新答案
		return; 
	}
	for(auto i:plan[dep]){//枚举每一种扩展方法 
		if(check(i)){//下一个节点撞墙了 
			continue;
		}
		moveplan(GO_TO,i);//去下一个节点 
		dfs(i);//下一个节点 
		moveplan(COME_BACK,i);//从下一个节点回溯 
	}
}
dfs 的种类
  • 全排列类型。即遍历全排列，为 O ⁡ ( n × n ! ) \operatorname{O}(n\times n!) O(n×n!)。由于时间过大，所以只能够应对 1 ≤ n ≤ 10 1\le n\le 10 1≤n≤10。
int n,ans[MAXN];
bool vis[MAXN];
void dfs(int dep){
	if(dep==n+1){
		for(int i=1;i<=n;++i){
			printf("%d ",ans[i]);//输出结果 
		}
		putchar('\n');
		return;
	}
	for(int i=1;i<=n;++i){
		if(!vis[i]){//如果在此之前没有出现过 
			ans[dep]=i;
			vis[i]=true;//标记 vis 
			dfs(dep+1);//继续搜索 
			vis[i]=false;//回溯 
		}
	}
}
  • 组合计数，从 n n n 个数里面选择 m m m 个数，发现枚举到 i i i 可以不用再回头枚举，所以设定 l a s t last last 表示上一个搜索的数，下一次直接从 l a s t + 1 last+1 last+1 开始枚举就可以了。这样子使得每一个集合只能够被遍历一次，时间复杂度 O ⁡ ( m × C n m ) \operatorname{O}(m\times C_n^m) O(m×Cnm​)。
int n,m,ans[MAXN];
void dfs(int dep,int last){
	if(dep==m+1){
		for(int i=1;i<=m;++i){
			printf("%d ",ans[i]);//输出结果 
		}
		putchar('\n');
		return;
	}
	for(int i=last+1;i<=n;++i){
		ans[dep]=i;//标记答案 
		dfs(dep+1,i);//继续搜索 
	}
}
  • 枚举子集，考虑每一个点只能够有出现和没出现两种状态，因此时间复杂度为 O ⁡ ( 2 n ) \operatorname{O}(2^n) O(2n)。
int n,top,ans[MAXN];
void dfs(int dep){
	if(dep==n+1){
		for(int i=1;i<=top;++i){
			printf("%d ",ans[i]);//输出结果 
		}
		putchar('\n');
		return;
	}
	ans[++top]=dep;
	dfs(dep+1);//选 
	--top;//回溯 
	dfs(dep+1);//不选 
}
  • 图上/树上 dfs，按照边来往外扩展即可。由于形式多样，也是给出模板代码。
struct node{
	int to,next;
}edge[MAXM<<1];
int n,m,cnt,head[MAXN];
inline void addedge(int from,int to){
	edge[++cnt].to=to;
	edge[cnt].next=head[form];
	head[from]=cnt;
}
void dfs(int from,int fa){
	makeanswer(from);//处理答案，可以用于树形 dp
	for(int i=head[from];i;i=edge[i].next){//遍历图或者树 
		int to=edge[i].to;
		if(to!=fa){//判断回溯 
			dfs(to,from);//同样格式 
		}
	} 
}
  • 网格 dfs，最经典的套题，通常是每一步可以向周围走一格，太模板了。
int n,m;
int dx[4]={0,-1,0,1};
int dy[4]={1,0,-1,0};
bool vis[MAXN][MAXN]; 
void dfs(int x,int y){
	if(checkfinish(x,y)){//判断结束 
		moveanswer();//更新答案或者结束
		return; 
	}
	for(int i=0;i<4;++i){
		int nx=x+dx[i];
		int ny=y+dy[i];
		if(1<=nx&&nx<=n&&1<=ny&&ny<=m&&vis[nx][ny]&&checkpoint(nx,ny){//下一个节点合法 
			move(COME_TO);
			vis[nx][ny]=true;
			dfs(nx,ny);//下一个节点 
			move(COME_BACK);
			vis[nx][ny]=false;//回溯 
		}
	}
}
例题1

板子题，图上 dfs，首先建边，要建无向图。然后枚举每一个点作为起点往后搜的最大答案，取 max ⁡ \max max，为了保证第一个点的父节点不冲突，通常赋值 0 0 0。还需要标记 vis数组，不然环会直接死递归爆栈。

#include<algorithm> 
#include<cstdio>
#define MAXN 22
#define MAXM 55
using namespace std;
struct node{
	int from,to,next,dis;
}edge[MAXM<<1]; 
int n,m,cnt,ans,head[MAXN];
bool vis[MAXN];
inline void addedge(int from,int to,int dis){
	edge[++cnt].from=from;
	edge[cnt].to=to;
	edge[cnt].dis=dis;
	edge[cnt].next=head[from];
	head[from]=cnt;
}
void dfs(int from,int fa,int step){
	vis[from]=true;
	ans=max(ans,step);
	for(int i=head[from];i;i=edge[i].next){
		int to=edge[i].to;
		if(to!=fa&&!vis[to]){
			dfs(to,from,step+edge[i].dis);
		}
	}
	vis[from]=false;
}
int main(){
	scanf("%d %d",&n,&m);
	while(m--){
		int from,to,dis;
		scanf("%d %d %d",&from,&to,&dis);
		addedge(from,to,dis);
		addedge(to,from,dis);
	}
	for(int i=1;i<=n;++i){
		dfs(i,0,0);
	}
	printf("%d",ans);
	return 0;
}
例题2

属于枚举从 n n n 个数里面选择 m m m 个数，再加上结尾判断质数的 1 0 8 = 1 0 4 \sqrt{10^8}=10^4 108 ​=104，则最大是 C n k × 1 0 4 C_n^k\times 10^4 Cnk​×104，不会超时。

#include<cstdio>
#define MAXN 22
using namespace std;
typedef long long ll;
int n,k,ans,a[MAXN];
inline bool prime(int n){
	if(n<=1){
		return false;
	}
	for(int i=2;i*i<=n;++i){
		if(n%i==0){
			return false;
		}
	}
	return true;
}
void dfs(int dep,int sum,int last){
	if(dep==k+1){
		if(prime(sum)){
			++ans;
		}
	}
	for(int i=last+1;i<=n;++i){
		dfs(dep+1,sum+a[i],i);
	}
}
int main(){
	scanf("%d %d",&n,&k);
	for(int i=1;i<=n;++i){
		scanf("%d",&a[i]);
	}
	dfs(1,0,0);
	printf("%d",ans);
	return 0;
}

bfs

bfs 是英文名 breath-first-search 的缩写，它的思想是逐步扩展，搜到即停。也就是 bfs 是把每一个深度的所有节点扩展出来，一旦出现了答案，并且答案要最优且深度最浅，那么这个就是答案，可以停止搜索了。

这么来讲，你需要找到一棵树上最靠前的一个权值为 2 2 2 的节点，那么可以用 bfs 来实现。bfs 将每一个节点的下表压入队列，然后逐步弹出队头。如果看到了 2 2 2，那就是最靠前的。

下面，给出 bfs 的伪代码：

inline void bfs(node st,node en){//node 为扩展答案的类型 
	queue<node> q;
	q.push(st);
	moveplan(GO_TO,st);//去下一个节点 
	while(!q.empty()){
		node front=q.front();
		q.pop();
		if(front==en){
			ans=front;//找到答案 
			return;
		}
		moveplan(COME_BACK,front);//从下一个节点回溯
		for(auto i:plan[front]){//枚举每一种扩展方法
			if(check(i)){//下一个节点撞墙了 
				continue;
			}
			q.push(i);
			moveplan(GO_TO,i);//去下一个节点 
		}
	}
	ans=unfound();//无解 
}

此外，bfs 还有众多的优化方式。形如双端队列、优先队列、A-star 等算法。

例题

这一道题目可以看作最优性答案，所以用 bfs 实现。考虑加一个偏移数组 d d d，来表示向上走还是向下走。然后枚举向上走还是向下走，压入队列。

#include<bits/stdc++.h>
#define MAXN 202
using namespace std;
struct node{
	int pos,step;
};
int n,ans,a[MAXN],vis[MAXN];
int d[2]={-1,1};
queue<node>q;
inline void bfs(int st,int en){
	queue<node> q;
	q.push((node){st,0});
	vis[st]=true;
	while(!q.empty()){
		node front=q.front();
		q.pop();
		if(front.pos==en) {
			ans=front.step;
			return;
		}
		for(int i=0;i<2;++i){
			int nxt=front.pos+d[i]*a[front.pos];
			if(nxt>=1&&nxt<=n&&!vis[nxt]){
				q.push((node){nxt,front.step+1});
				vis[nxt]=true;
			}
		}
	}
	ans=-1;
}
int main(){
	int st,en;
	scanf("%d %d %d",&n,&st,&en);
	for(int i=1;i<=n;++i){
		scanf("%d",&a[i]);
	}
	bfs(st,en);
	printf("%d",ans);
	return 0;
}

此外，所有 bfs 优化放在剪枝后面介绍。

总结

来分析一下，dfs 适用于统计答案个数的题目，优点是空间最大是 O ⁡ ( n ) \operatorname{O}(n) O(n)，但是时间可能是指数级别的。bfs 适用于求最优性答案的题目，优点是较快，但是由于 queue耗用空间很大，空间最坏能够达到指数级大小。

剪枝

剪枝的思想是把搜索树的一部分一定不满足答案的部分剪掉，如果剪枝精妙，再加上一些小优化或者玄学优化，可以把指数级别的搜索优化到多项式级别，甚至获得高分乃至 100 100 100 分。

剪枝分为以下几个：

正确性剪枝

这个通常来讲是优化正确性的，比如 dfs 例题，里面使用了 v i s vis vis 数组进行剪枝，减去了 { 1 , 1 , 1 } \{1,1,1\} {1,1,1} 的不合法情况。

最优性剪枝

这个是 bfs 能够很快的思想之一，就是如果当前答案没有已经求出的答案那么优，就不扩展。bfs 就是证明了搜到深度最小的答案，不可能有答案比它再优了才退出的。

记忆化搜索

有时候，dfs 会多次访问同一个节点。比如 d f s ( 3 , 3 ) dfs(3,3) dfs(3,3) 可以扩展成 d f s ( 2 , 2 ) dfs(2,2) dfs(2,2)，而你又在此之前查询了 d f s ( 2 , 2 ) dfs(2,2) dfs(2,2)，这明显可以用一个数组 f f f 来存储。在此之前，有 d f s ( 2 , 2 ) dfs(2,2) dfs(2,2) 的存在，那么设 c n t cnt cnt 为访问 d f s ( 2 , 2 ) dfs(2,2) dfs(2,2) 的次数， t t t 为 d f s ( 2 , 2 ) dfs(2,2) dfs(2,2) 的时间，那么可以优化 ( c n t − 1 ) × ( t − 1 ) (cnt-1)\times (t-1) (cnt−1)×(t−1) 的时间。

例题1

这一道题目在 dfs 的基础上需要有剪枝。很明显， d e p dep dep 曾的 i i i 必须从上一个 i i i 枚举到之前的答案加上 ( k − d e p ) × i (k-dep)\times i (k−dep)×i，这是一个剪枝。

#include<bits/stdc++.h>
using namespace std;
int n,k,ans;
void dfs(int dep,int sum,int last){
	if(dep==k){
		ans+=(sum==n);
		return;
	}
	for(int i=last;sum+(k-dep)*i<=n;++i){
		dfs(dep+1,sum+i,i);
	}
}
int main(){
	scanf("%d %d",&n,&k);
	dfs(0,0,1);
	printf("%d",ans);
	return 0;
}

例题2

这一道题目需要使用最优性剪枝，即如果拼出的目标长度大于了目标长度，那就跳过，因为这样肯定有一个更优的答案小于目标长度。

#include<bits/stdc++.h>
#define MAXN 101
using namespace std;
int n,cnt,maxi=INT_MIN,mini=INT_MAX;
int a[MAXN],ans[MAXN];
void dfs(int dep,int now,int len,int pos){
    if(!dep){
		printf("%d",len);
		exit(0);
	}
    if(now==len){
		dfs(dep-1,0,len,maxi);
		return;
	}
    for(int i=pos;i>=mini;--i){
        if(ans[i]&&i+now<=len){
            --ans[i];
            dfs(dep,i+now,len,i);
            ++ans[i];
            if(!now||now+i==len){
				break;
			}
        }
	}
}
int main(){
    scanf("%d",&n);
    int len,sum=0;
    while(n--){
        scanf("%d",&len);
        if(len<=50){
            a[++cnt]=len;
            maxi=max(maxi,len);
            mini=min(mini,len);
            ++ans[len];
			sum+=len;
        }
    }
    len=sum>>1;
    for(int i=maxi;i<=len;++i){
		if(sum%i==0){
			dfs(sum/i,0,i,maxi);
		}
	}
    printf("%d",sum);
    return 0;
}

例题3

这一道题目是求 w ( x , y , z ) w(x,y,z) w(x,y,z)，很明显满足 dfs。考虑记忆化搜索，这样，就可以避免大量的无意义运算。最多 2 0 3 20^3 203 次的不同的运算求出 a n s ans ans，那么之后就只需要求 w ( x , y , z ) = a n s x , y , z w(x,y,z)=ans_{x,y,z} w(x,y,z)=ansx,y,z​ 了。

#include<bits/stdc++.h>
#define MAXN 22
using namespace std;
typedef long long ll;
ll ans[22][22][22];
inline ll dfs(int x,int y,int z){
	if(x<=0||y<=0||z<=0){
		return ans[0][0][0]=1;
	}
	if(x>20||y>20||z>20){
		return dfs(20,20,20);
	}
	if(ans[x][y][z]){
		return ans[x][y][z];
	}
	if(x<y&&y<z){
		return ans[x][y][z]=dfs(x,y,z-1)+dfs(x,y-1,z-1)-dfs(x,y-1,z);
	}
	return ans[x][y][z]=dfs(x-1,y,z)+dfs(x-1,y-1,z)+dfs(x-1,y,z-1)-dfs(x-1,y-1,z-1);
}
int main(){
	while(true){
		ll x,y,z;
		scanf("%lld %lld %lld",&x,&y,&z);
		if(x==-1&&y==-1&&z==-1){
			return 0;
		}
		printf("w(%lld, %lld, %lld) = %lld\n",x,y,z,dfs(x,y,z));
	}
	return 0;
}

bfs 优化

双向 bfs

双向 bfs 的思想是每一次同时从起点和终点同时搜索，搜索到重合就可以得出答案。

例如，根节点可以衍生出深度为 n n n 的搜索树，时间复杂度为 O ⁡ ( 2 n ) \operatorname{O}(2^n) O(2n)，但是如果用折半搜索，开头可以衍生出深度为 ⌊ n 2 ⌋ \lfloor\frac{n}{2}\rfloor ⌊2n​⌋ 的搜索树，结尾可以衍生出深度为 ⌈ n 2 ⌉ \lceil\frac{n}{2}\rceil ⌈2n​⌉ 的搜索树，时间复杂度为 2 ⌈ n 2 ⌉ + 1 2^{\lceil\frac{n}{2}\rceil+1} 2⌈2n​⌉+1。

例题

可以从开头状态和结尾状态同时搜索，用的步数用 map记录下来。套用双向 bfs 板子即可。

由于双向 bfs 例题太难找了，所以只找了正常 bfs 也能过的题目。

#include<iostream>
#include<string>
#include<queue>
#include<map> 
using namespace std;
string s,t,a[10],b[10];
int n=1;
inline int bfs(){
	map<string,int> mp1,mp2;
	queue<string> q1,q2;
	int step=0;
	q1.push(s);
	mp1[s]=0;
	q2.push(t);
	mp2[t]=0;
	string s,s2;
	while(++step<=5){
		while(mp1[q1.front()]==step-1){
			s=q1.front();
			q1.pop();
			for(int i=1;i<=n;++i){
				size_t pos=0;
				while(pos<s.size()){
					if(s.find(a[i],pos)==s.npos)break;
					s2=s;
					s2.replace(s2.find(a[i],pos),a[i].size(),b[i]);
					if(mp1.find(s2)!=mp1.end()){
						++pos;
						continue;
					}
					if(mp2.find(s2)!=mp2.end()){
						return step*2-1;
					}
					q1.push(s2);
					mp1[s2]=step;
					++pos;
				}
			}
		}
		while(mp2[q2.front()]==step-1){
			s=q2.front();
			q2.pop();
			for(int i=1;i<=n;++i){
				size_t pos=0;
				while(pos<s.size()){
					if(s.find(b[i],pos)==s.npos)break;
					s2=s;
					s2.replace(s2.find(b[i],pos),b[i].size(),a[i]);
					if(mp2.find(s2)!=mp2.end()){
						++pos;
						continue;
					}
					if(mp1.find(s2)!=mp1.end()){
						return step*2;
					}
					q2.push(s2);
					mp2[s2]=step;
					++pos;
				}
			}
		}
	}
	return -1;
}
int main(){
	cin>>s>>t;
	while(cin>>a[n]>>b[n]){
		n++;
	}
	int ans=bfs();
	if(ans==-1){
		cout<<"NO ANSWER!";
	}else{
		cout<<ans;
	}
	return 0;
}

双端队列优化

双端队列优化用于 01bfs，由于每一个点的权值一定是 0 0 0 或者 1 1 1，虽然不同，但是把 0 0 0 从队头入队， 1 1 1 从队尾入队仍然满足第一个就是答案。

例题

很明显，每一个权值扩展只可能是 0 0 0 或者 1 1 1。如果为 0 0 0，那么放在队首，反之，放在队尾。用 d i s x , y dis_{x,y} disx,y​ 记录答案，并进行松弛即可。

#include<cstring>
#include<cstdio>
#include<deque>
#define MAXN 505
using namespace std;
struct node{
	int x,y,step;
};
int n,m,sx,sy,tx,ty;
char mp[MAXN][MAXN];
bool vis[MAXN][MAXN];
int dis[MAXN][MAXN];
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
inline int bfs(int sx,int sy){
	memset(vis,0,sizeof(vis));
	memset(dis,0x3f,sizeof(dis));
	deque<node> q;
	q.push_back((node){sx,sy,0});
	vis[sx][sy]=true;
	dis[sx][sy]=0;
	while(!q.empty()){
		int x=q.front().x;
		int y=q.front().y;
		int step=q.front().step;
		q.pop_front();
		if(x==tx&&y==ty){
			return step;
		}
		for(int i=0;i<4;++i){
			int nx=x+dx[i];
			int ny=y+dy[i];
			if(!(1<=nx&&nx<=n&&1<=ny&&ny<=m)){
				continue;
			}
			if(dis[nx][ny]>step+(mp[x][y]==mp[nx][ny])){
				dis[nx][ny]=step+(mp[x][y]==mp[nx][ny]);
				if(!vis[nx][ny]){
					vis[nx][ny]=true;
					if(mp[x][y]==mp[nx][ny]){
						q.push_front((node){nx,ny,step});
					}else{
						q.push_back((node){nx,ny,step+1});
					}
				}
			}
		}
	}
	return -1;
}
inline void work(){
	for(int i=1;i<=n;++i){
		scanf("%s",mp[i]+1);
	}
	scanf("%d %d %d %d",&sx,&sy,&tx,&ty);
	++sx;
	++sy;
	++tx;
	++ty;
	printf("%d\n",bfs(sx,sy));
}
int main(){
	while(~scanf("%d %d",&n,&m)&&n&&m){
		work();
	}
	return 0;
}

优先队列优化

优先队列优化和双端队列优化的形式差不多，都是为了维持对内元素的单调性而产生的。思想是维护 bfs 的“搜到即停”的性质。在每次扩展结点深度不止加 1 1 1 的时候，对内元素可能不是有序的，需要使用数据结构维护单调性。（盲猜线段树或者平衡树也可以）

类似于 Dijiestra，每次把最小的出队，如果这就是答案，那么其余对内元素即使有答案也不会比这个更优。如果不是，那就继续扩展出来新的节点。

例题

是 Dijiestra 的经典板子。思想同上，还可以用线段树优化和平衡树优化，平衡树和堆效果相同，而且常数和空间更大，因此不推荐使用。

#include<cstring>
#include<cstdio>
#include<queue>
#define MAXN 100001
#define MAXM 200002
using namespace std;
typedef long long ll;
struct node{
	int next,to;
	ll dis;
}edge[MAXM];
int cnt,head[MAXN];
ll dis[MAXN];
bool vis[MAXN];
inline void addedge(int from,int to,ll dis){
	edge[++cnt].to=to;
	edge[cnt].dis=dis;
	edge[cnt].next=head[from];
	head[from]=cnt;
}
inline void Dijiestra(int s){
	memset(dis,0x7f,sizeof(dis));
	memset(vis,0,sizeof(vis));
	dis[s]=0ll;
	priority_queue<pair<ll,int>,vector<pair<ll,int> >,greater<pair<ll,int> > > q;
	q.push(make_pair(0ll,s));
	while(!q.empty()){
		int from=q.top().second;
		q.pop();
		vis[from]=false;
		for(int i=head[from];i;i=edge[i].next){
			int to=edge[i].to;
			if(dis[to]>dis[from]+edge[i].dis){
				dis[to]=dis[from]+edge[i].dis;
				if(!vis[to]){
					q.push(make_pair(dis[to],to));
					vis[to]=true;
				}
			}
		}
	}
}
int main(){
	int n,m,s;
	scanf("%d %d %d",&n,&m,&s);
	while(m--){
		int from,to;
		ll dist;
		scanf("%d %d %lld",&from,&to,&dist);
		addedge(from,to,dist);
	}
	Dijiestra(s);
	for(int i=1;i<=n;++i){
		printf("%lld ",dis[i]);
	}
	return 0;
}

折半搜索

折半搜索是可以将指数折半的一种搜索，它的思想就是确定某一种意义下的 h e a d 1 head1 head1 和 h e a d 2 head2 head2，然后往后搜索。有些情况，搜索出来会使得 t a i l 1 = t a i l 2 tail1=tail2 tail1=tail2，而有些情况，会使得 t a i l 1 + 1 = h e a d 2 tail1+1=head2 tail1+1=head2。不管怎么样，如果最开始是 k n k^n kn 会爆，那么折半搜索能优化到 k ⌊ n 2 ⌋ + 1 k^{\lfloor\frac{n}{2}\rfloor+1} k⌊2n​⌋+1 的复杂度。

例题

这一道题目可以枚举每一种状态选或者不选，复杂度 2 n 2^n 2n。但是 n n n 可以达到 40 40 40，所以考虑折半。折半搜索的结果是可以拼凑出多少种不同的方案，用 dfs 实现。一半枚举 2 ( 1 , ⌊ n 2 ⌋ ) 2^{(1,\lfloor\frac{n}{2}\rfloor)} 2(1,⌊2n​⌋)，一半枚举 2 ( ⌊ n 2 ⌋ + 1 , n ) 2^{(\lfloor\frac{n}{2}\rfloor+1,n)} 2(⌊2n​⌋+1,n)，然后二分查找出耗费了前半段那么多钱，后半段能够耗费多少钱，然后统计即可。

#include<bits/stdc++.h>
#define MAXN 41
#define MAXM 1<<20|1
using namespace std;
typedef long long ll;
int n,cnta,cntb;
ll m,w[MAXN],suma[MAXM],sumb[MAXM],ans;
void dfs(int l,int r,ll sum,ll a[],int &cnt){
    if(sum>m){
    	return;
	}
    if(l>r){
        a[++cnt]=sum;
        return;
    }
    dfs(l+1,r,sum+w[l],a,cnt);
    dfs(l+1,r,sum,a,cnt);
}
int main(){
    scanf("%d %lld",&n,&m);
    for(int i=1;i<=n;++i){
    	scanf("%lld",&w[i]);
	}
    int mid=n>>1;
    dfs(1,mid,0,suma,cnta);
    dfs(mid+1,n,0,sumb,cntb);
    sort(suma+1,suma+1+cnta);
    for(int i=1;i<=cntb;++i){
    	ans+=upper_bound(suma+1,suma+1+cnta,m-sumb[i])-suma-1;
	}
    printf("%lld",ans);
    return 0;
}

A-star

A-star 属于玄学时间算法。它的思想是对于每一个点 p p p，都有从 h e a d head head 到 p p p 的函数 p r e ( p ) pre(p) pre(p)，也有从 p p p 到 t a i l tail tail 的函数 n x t ( p ) nxt(p) nxt(p)，还有估价函数 g o a l ( p ) = p r e ( p ) + n x t ( p ) goal(p)=pre(p)+nxt(p) goal(p)=pre(p)+nxt(p)，然后以估价函数的值来搜索。在此之前，我们还需要引入一个定理：优先队列优化 bfs。

通用的估价函数 g o a l goal goal 有以下几个形式：

  • 哈曼顿距离，即两个点在平面上无障碍在平行的线上需要走的距离。
inline int goal(int a,int b){
	return abs(x[a]-x[b])+abs(y[a]-y[b]);//哈曼顿距离 
}
  • 对角线，这个是应用于 8 8 8 个方向的网格图。
inline int goal(int a,int b){
	return max(abs(x[a]-x[b]),abs(y[a]-y[b]));//对角线距离 
}
  • 直线距离，即两个点走直线。
inline int goal(int a,int b){
	return sqrt((x[a]-x[b])*(x[a]-x[b])+(y[a]-y[b])*(y[a]-y[b]));//直线距离 
}

优先队列优化 bfs 在一次性扩展深度不一定加一的 bfs 中用于规划最小值，每一次取出的是最优的，那就满足了 bfs 的自带的最优性剪枝。优先队列优化本质上也是贪心加上最优性剪枝。

这些函数满足三角形不等式，所以 bfs 的证明是正确的。事实上，A-star 还可以变式成堆优化的 Dijiestra。

例题

这道题目就是求 K 短路径。可以考虑设置 p r e pre pre 函数为当前距离，这个可以用 Dijiestra 预处理。之后的 n x t nxt nxt 可以考虑用当前路径的长度，这样还是满足三角形不等式的，所以，之后用 A-star 跑。

#include<bits/stdc++.h>
#define MAXN 1001
#define MAXM 10001
using namespace std; 
typedef long long ll;
typedef pair<ll,int> pli;
struct node{
	int next,to;
	ll dis;
}edge[MAXM][2];
struct cmp{
	int pos;
	ll dis;
};
int n,m,k,cnt[2],head[MAXN][2];
ll dis[MAXN];
bool vis[MAXN];
inline bool operator<(const cmp &x,const cmp &y){
	return x.dis+dis[x.pos]>y.dis+dis[y.pos];
}
inline void addedge(int x,int from,int to,ll dis){
	edge[++cnt[x]][x].to=to;
	edge[cnt[x]][x].dis=dis;
	edge[cnt[x]][x].next=head[from][x];
	head[from][x]=cnt[x];
}
inline void dijiestra(){
	priority_queue<pli,vector<pli>,greater<pli> > q;
	q.push(make_pair(0ll,1));
	memset(dis,0x7f,sizeof(dis));
	dis[1]=0;
	vis[1]=true;
	while(!q.empty()){
		int front=q.top().second;
		q.pop();
		vis[front]=false;
		for(int i=head[front][1];i;i=edge[i][1].next){
			int to=edge[i][1].to;
			if(dis[to]>dis[front]+edge[i][1].dis){
				dis[to]=dis[front]+edge[i][1].dis;
				if(!vis[to]){
					q.push(make_pair(dis[to],to));
					vis[to]=true;
				}
			}
		}
	}
}
inline void A_star(){
	priority_queue<cmp> q;
	q.push((cmp){n,0ll});
	while(!q.empty()){
		cmp front=q.top();
		q.pop();
		if(front.pos==1){
			printf("%lld\n",front.dis);
			if((--k)==0){
				return;
			}
			continue; 
		}
		int from=front.pos;
		for(int i=head[from][0];i;i=edge[i][0].next){
			int to=edge[i][0].to;
			q.push((cmp){to,front.dis+edge[i][0].dis});
		}
	}
}
int main(){
	scanf("%d %d %d",&n,&m,&k);
	if(!k){
		return 0;
	}
	while(m--){
		int from,to;
		ll dis;
		scanf("%d %d %lld",&from,&to,&dis);
		addedge(0,from,to,dis);
		addedge(1,to,from,dis);
	}
	dijiestra();
	A_star();
	while(k--){
		puts("-1");
	}
	return 0;
}

为什么说玄学时间算法？因为有时候 A-star 并不能够优化时间，在考场上能造出数据点卡 A-star，K 短路问题还需要通过其他的方式算出来，比如可持久化可并堆，详见【模板】k 短路 / [SDOI2010] 魔法猪学院。

ID

ID 是 iterate-deepning 的缩写，中翻迭代加深搜索。主要思想是结合了 dfs 和 bfs 的思想，每一次设置一个深度 d e p dep dep，如果深度超过 d e p dep dep，那就再把 d e p + 1 dep+1 dep+1，如果搜到了最佳答案，那就结束。ID 优化了 bfs 的空间不足和 dfs 的时间不足。

例题

这一道题目可以考虑枚举个数，用 ID 来搜。然后要搜分母，统计答案。此外，还需要正确性剪枝。每一次如果 x × n x t ≥ y × ( m a x d e p − d e p + 1 ) x\times nxt\ge y\times(maxdep-dep+1) x×nxt≥y×(maxdep−dep+1)，那么一定不合法。

#include<bits/stdc++.h>
#define MAXN 202
#define MAXM 1001
using namespace std;
typedef long long ll;
int maxdep;
ll n,m,zip[MAXN],ans[MAXN];
bool f=true;
inline bool check(){
	for(int i=maxdep;i>=1;--i){
		if(!ans[i]){
			return true;
		}else if(ans[i]!=zip[i]){
			return zip[i]<ans[i];
		}
	}
	return false;
}
void iddfs(int dep,ll x,ll y,ll last){
	if(dep==maxdep){
		if(y%x){
			return; 
		}
		zip[maxdep]=y/x;
		if(check()){
			for(int i=1;i<=maxdep;++i){
				ans[i]=zip[i];
			}
		}
		f=false;
		return;
	}
	for(ll i=max(last,y/x+1);x*i<y*(maxdep-dep+1);++i){
		ll nxtx=x*i-y;
		ll nxty=y*i;
		zip[dep]=i;
		ll g=__gcd(nxtx,nxty);
		iddfs(dep+1,nxtx/g,nxty/g,i+1);
	}
}
int main(){
	scanf("%lld %lld",&n,&m);
	f=true;
	for(maxdep=2;f;++maxdep){
		memset(zip,0,sizeof(zip));
		iddfs(1,n,m,n/m+1);
	}
	--maxdep;
	for(int i=1;i<=maxdep;++i){
		printf("%lld ",ans[i]);
	}
}

IDA-star

IDA-star 是结合了 A-star 和 ID 的算法，它的具体实现是 dfs，只不过是每次需要 g o a l goal goal 进行扩展。A-star 优化的是 bfs，ID 优化的是所有广搜，那么正好 ID 可以优化 A-star。相较于 A-star，IDA-star 的优势是空间。

例题

这一道题目，需要在 15 15 15 步内走完，很像 ID 的 m a x d e p maxdep maxdep 限制条件，然后可以考虑 g o a l goal goal 函数定义成至少要多少步，典型的 A-star，之后，再加上一些剪枝优化即可。

#include<bits/stdc++.h>
#define MAXN 6
using namespace std;
char a[MAXN][MAXN];
char mp[MAXN][MAXN]={
	{'0','0','0','0','0','0'},
	{'0','1','1','1','1','1'},
	{'0','0','1','1','1','1'},
	{'0','0','0','*','1','1'},
	{'0','0','0','0','0','1'},
	{'0','0','0','0','0','0'}
};
int dx[9]={0,-2,-2,-1,-1,1,1,2,2};
int dy[9]={0,-1,1,-2,2,-2,2,-1,1},ans;
inline int goal(){
	int val=0;
	for(int i=1;i<=5;++i){
		for(int j=1;j<=5;++j){
			if(a[i][j]!=mp[i][j]){
				++val;
			}
		}
	}
	return val;
}
void dfs(int x,int y,int dep,int last){
	int val=goal();
	if(dep+val>16||dep>=ans){
		return;
	}
	if(val==0){
		ans=dep;
		return;
	}
	for(int i=1;i<=8;++i){
		if(x+dx[i]<1||x+dx[i]>5||y+dy[i]<1||y+dy[i]>5){
			continue;
		}
		if(last+i!=9){
			swap(a[x][y],a[x+dx[i]][y+dy[i]]);
			dfs(x+dx[i],y+dy[i],dep+1,i);
			swap(a[x][y],a[x+dx[i]][y+dy[i]]);
		}
	}
	return;
}
inline void work(void){
	for(int i=1;i<=5;++i){
		scanf("%s",a[i]+1);
	}
	int sx,sy;
	for(int i=1;i<=5;++i){
		for(int j=1;j<=5;++j){
			if(a[i][j]=='*'){
				sx=i;
				sy=j;
			}
		}
	}
	ans=INT_MAX;
	dfs(sx,sy,0,0);
	printf("%d\n",ans==INT_MAX?-1:ans);
}
int main(){
	int t;
	scanf("%d",&t);
	while(t--){
		work();
	}
	return 0;
}
hisy_qwq
关注
专栏目录
大语言模型应用指南：从人工智能的起源到大语言模型
AI天才研究院
06-27 979
人工智能（Artificial Intelligence，AI）自诞生以来，一直是计算机科学领域的重要研究方向。早期的AI系统主要依赖于专家知识和规则库，通过逻辑推理和符号计算来解决问题。然而，这种基于规则的系统在处理复杂和多变的现实世界时，表现出了明显的局限性。随着数据量的爆炸式增长和计算能力的提升，研究者们开始探索基于数据驱动的机器学习方法，尤其是深度学习（Deep Learning），从而引发了AI领域的革命性进展。
启发式搜索详解
Like_Ginger的博客
08-26 2915
阅前必读 本博客纯手写，无借鉴，请大胆的提意见哦QwQ 优先队列BFS 回顾普通BFS——BFS+普通队列 BFS是什么 BFS，宽度优先搜索。 它的搜索方式就像涟漪一样，是一层一层遍历下去。具体见下图： cnt表示遍历的层次。 所谓“涟漪式”的遍历，其实就是以层次的不断向目标状态展开，对图中每一个点的最优值更新，从而达到遍历至目标状态时的最优值。 BFS可以干什么？ 一般出现最短路径和最佳方案时可以使用BFS遍历。 BFS+普通队列怎么写？ 下面是伪代码： void BFS(int x) { 初始化队列Q
动态规划指南 QwQ
hisy_qwq的博客
09-23 251
有时候，可以暴力拆成若干个 01 背包，但是有时候空间和时间都不支持。树形 dp 是通过树的顺序或者图的拓扑序来进行的 dp。通常来讲，子节点继承父节点的状态或者父节点继承诸多子节点的状态。可以看出这一个式子似乎能够优化所有转移方程只带加法和乘法的 dp。的最优决策点都会处理到，并且可以合并答案，类似于区间 dp，可以优化到。有时候，线性 dp 是需要结合其他的方法优化或者证明的。线性 dp，就是指 dp 只有一维的 dp。状压 dp，就是把一些维度压缩成一个维度的 dp。矩阵快速幂是用于优化 dp 的。
干货 | 深度学习模型超参数搜索实用指南
mxs1123的博客
09-30 437
https://mp.weixin.qq.com/s/wG_N6hKlKXcrXrAhzj3QwQ 乾明 整理编译自 FloydHub Blog 量子位 报道 | 公众号 QbitAI 在文章开始之前，我想问你一个问题：你已经厌倦了小心翼翼地照看你的深度学习模型吗？ 如果是的话，那你就来对地方了。 近日，FloydHub Blog发表了一篇文章，详细讨论了为深度学习模型寻找最佳超参数集的有...
《算法竞赛进阶指南》刷题记录
qq_42692055的博客
11-20 458
总算闲下来一些辣！然后最近发现其实看书是真真很有效但是一直没有落实！所以决定落实一下这段时间把这本书看完题目做完！ 然后发现还有挺多题目挺巧妙的于是一堆博客预警,,,可能最近会写很多比较水(但是我还是不会做)的题目的题解 啊还有就是依然是[ ]表示没写 [X]表示已经写完辣! 本来是染色标明要不要写题解的,然而染色太麻烦了QAQ所以就写完题解&&写完代码才会是[X]!...
算法竞赛进阶指南 0x00 基本算法
banyibai6275的博客
09-02 396
放在原来这个地方不太方便，影响阅读体验。为了读者能更好的刷题，另起一篇随笔。 0x00 基本算法 0x01 位运算 [题目][64位整数乘法] 知识点：快速幂思想的灵活运用 [题目][最短Hamilton路径] 知识点： 状压DP。我的题解总是写得不好，大家还是看书吧qwq P2114 [NOI2014]起床困难综合症 知识点：状态压缩 0x02 递推与递归 [题目][费解的开关] 知识...
算法竞赛进阶指南 0x30 数学知识
mrcrack的博客
02-12 1631
算法竞赛进阶指南 0x30 数学知识 本书有在线测评网站的支持，是一大亮点，又是NOI经历者编写的，故赶紧入手一本，抓紧时间研读，希望能通过该书建立较为完整的知识体系。先从最为薄弱，但又想尽快提升的数学入手。2018-2-12 20:33 http://begin.lydsy.com/JudgeOnline/problemset.php?page=38 0x31 质数 //4789: Po...
Let‘sEncrypt快速颁发及自动续签泛域名证书实践指南
WeiyiGeek 唯一极客IT知识分享
03-12 4709
本章目录：0x00 前言简述0x01 快速安装配置1.acme.sh0x02 证书自动签发实践1.acme.sh + Cloudflare 实现自动签发泛域名证书。0x02 使用实例1.简单示例2.扩展补充0x03 入坑出坑1.Cloudflare 的API 不技持 .cf, .ga, .gq, .ml, or .tk 的域名申请证书0x00 前言简述描述: Let's ...
[大概是日常生活吧] 日常生活指南 （先自救。！！！）
ansu1440的博客
09-30 207
还需要注意什么呢 生活绝不是做个题目这么简单这样子 好好上课，哪怕是上课的时候把课本好好读一遍 1.\昨天搞excel表格,简单的东西搞了一个半小时 人又烦 重新陷入到焦头烂额中去了。。 【写表格/面对自己完全不熟悉的时候】 这个时候先去get一些信息 比如表格里的说明啊注释啊什么的。先别动手 奖学金那个底下其实不用写的。认认真真读完，认认真真读完之后就知道了，别上去不会...
PHP高端大气婚纱摄影婚庆策划机构网站源码.rar
11-12
6. **SEO优化**：考虑到搜索引擎优化，源码可能内置了关键词管理和元标签设置，帮助网站在搜索引擎结果中获得更好的排名。 7. **安全性**：源码应考虑了安全因素，如输入验证、防止SQL注入、XSS攻击等，保护用户...
VScode使用全指南 (环境配置，插件推荐，美化) (C++,Python,LaTeX,R...)
热门推荐
LiuKairui的博客
03-02 2万+
Visual Studio Code (简称 VS Code / VSC) 是一款免费开源的现代化轻量级代码编辑器，使用Web技术Electron搭建，支持几乎所有主流的开发语言的语法高亮、智能代码补全、自定义热键、括号匹配、代码片段、代码对比 Diff、GIT 等特性，支持插件扩展。软件跨平台支持 Windows、Mac 以及 Linux。 1.安装 搜索官网直接下载(推荐测试版insider)...
【C++算法】9.双指针_四数之和
最新发布
hlyd520的博客
10-04 423
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1127
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
排序算法之归并排序
qq_64039411的博客
10-01 492
需要注意的是，在实际应用中，归并排序的空间复杂度较高，需要额外的空间来存储临时数组。如果对空间复杂度有要求，可以考虑使用其他排序算法。归并排序是一种分治算法，它将一个数组分成两个子数组，然后递归地对子数组进行排序，最后将两个有序的子数组合并成一个有序的数组。归并排序的时间复杂度是O(nlogn)，其中n是数组的长度。它是一种稳定的排序算法，适用于各种数据类型的排序。合并排序的关键在于合并操作。
DAY17||654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索 |
2301_79865280的博客
09-29 1306
给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例 ：构造二叉树一定要，因为要先找到中，才能分割左右子树。本题图解思路：本题做过上一题构建数组确实变得容易很多。代码优化方向有，不用每次找左右子树的时候构建新的数组的话效率就会高很多。（即直接用下标索引直接在原数组上操作）关于加不加if的问题，如果允许空节点进入递归，就不加。
算法：按既定顺序创建目标数组
AWSDN的博客
09-29 238
本文主要介绍按既定顺序创建目标数组问题
【韩顺平Java笔记】第6章：数组、排序和查找
随手写写
10-02 714
排序是将多个数据，依指定的顺序进行排列的过程。
【算法】---归并排序（递归非递归实现）
何春秋的博客
10-03 982
归并排序 in Java
istringstream qwq(s);
03-31
istringstream是C++标准库中的一个类，用于将字符串作为输入流进行处理。它可以将字符串按照指定的分隔符进行分割，并将分割后的结果作为输入流进行读取。 在使用istringstream之前，需要包含头文件<sstream>。然后可以通过创建一个istringstream对象，并将要处理的字符串作为参数传入构造函数来初始化该对象。 例如，假设有一个字符串s，我们可以使用istringstream来对其进行处理： ```cpp #include <iostream> #include <sstream> int main() { std::string s = "Hello World"; std::istringstream iss(s); // 创建istringstream对象并初始化 std::string word; while (iss >> word) { // 以空格为分隔符，逐个读取分割后的单词 std::cout << word << std::endl; } return 0; } ``` 上述代码中，我们创建了一个名为iss的istringstream对象，并将字符串s作为参数传入构造函数进行初始化。然后，在while循环中，使用>>运算符从iss中逐个读取分割后的单词，并输出到标准输出流中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值