简单搜索

最新推荐文章于 2023-10-17 12:40:19 发布
最新推荐文章于 2023-10-17 12:40:19 发布
阅读量183 收藏
点赞数
分类专栏： 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bailichuan266/article/details/97006587
版权

棋盘问题 

#include<cstdio>
#include<cstring>
int vis[10];
char mp[10][10];
int n,k,sum,cnt;
void dfs(int s){
	if(cnt==k){
		sum++;
		return;
	}
	if(s>=n)
		return;
	for(int i=0;i<n;i++){
		if(!vis[i]&&mp[s][i]=='#'){
			vis[i]=1;
			cnt++;
			dfs(s+1);
			cnt--;
			vis[i]=0;
		}
	}
	dfs(s+1);
}
int main(){
	while(~scanf("%d%d",&n,&k)&&n!=-1&&k!=-1){
		for(int i=0;i<n;i++)
			scanf("%s",mp[i]);
		memset(vis,0,sizeof(vis));
		sum=cnt=0;
		dfs(0);
		printf("%d\n",sum);
	}
}

Dungeon Master

#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
using namespace std;
char s[35][35][35];
int vis[35][45][45];
int dir[7][4]={{1,0,0},{-1,0,0},{0,1,0},{0,-1,0},{0,0,1},{0,0,-1}};
int sx,sy,sz,ex,ey,ez;
int l,r,c;
struct node{
	int x,y,z,step;
	friend bool operator<(node a,node b){
		return a.step>b.step;
	}
};
priority_queue<node>q;
void bfs(){
	node q1;
	q1.x=sx,q1.y=sy,q1.z=sz,q1.step=0;
	q.push(q1);
	vis[sz][sx][sy]=1;
	while(!q.empty()){
		node a=q.top();
		q.pop();
		if(a.z==ez&&a.x==ex&&a.y==ey){
			printf("Escaped in %d minute(s).\n",a.step);
			return;
		}
		for(int i=0;i<6;i++){
			int zz=a.z+dir[i][0];
			int yy=a.y+dir[i][1];
			int xx=a.x+dir[i][2];
			if(s[zz][xx][yy]!='#'&&zz>=0&&zz<l&&yy>=0&&yy<c&&xx>=0&&xx<r&&!vis[zz][xx][yy]){
				vis[zz][xx][yy]=1;
				node b;
				b.x=xx;
				b.y=yy;
				b.z=zz;
				b.step=a.step+1;
				q.push(b);
			}
		}
	}
	printf("Trapped!\n");
}
int main(){
	
	while(~scanf("%d%d%d",&l,&r,&c)&&l+r+c){
		for(int i=0;i<l;i++){
			for(int j=0;j<r;j++){
				scanf("%s",s[i][j]);
				for(int k=0;k<c;k++){
					if(s[i][j][k]=='S'){
						sz=i;
						sx=j;
						sy=k;
					}
					if(s[i][j][k]=='E'){
						ez=i;
						ex=j;
						ey=k;
					}
				}
			}
		}
		memset(vis,0,sizeof(vis));
		bfs();
	}
}

Catch That Cow

#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
int n,k;
int vis[100005],d[100005];
int cnt;
void bfs(){
	memset(d,0x3f3f3f3f,sizeof(d));
	queue<int>q;
	q.push(n);
	vis[n]=1;
	d[n]=0;
	while(!q.empty()){
		int temp=q.front();
		q.pop();
		if(temp==k)
			break;
		for(int i=0;i<3;i++){
			int x;
			if(i==0)
				x=temp+1;
			if(i==1)
				x=temp-1;
			if(i==2)
				x=temp*2;
			if(x>0&&x<2*k&&!vis[x]){
				d[x]=d[temp]+1;
				vis[x]=1;
				q.push(x);
			}
		}
	}
}
int main(){
	while(~scanf("%d%d",&n,&k)){
		memset(vis,0,sizeof(vis));
		if(n>=k){
			printf("%d\n",n-k);
			continue;
		}
		bfs();
		printf("%d\n",d[k]);
	}
}

Fliptile

#include<cstdio>
#include<cstring>
int mp[20][20],fli[20][20],out[20][20];
int dir[6][2]={{0,0},{1,0},{-1,0},{0,1},{0,-1}};
int m,n;
int check(int x,int y){
	int c=mp[x][y];
	for(int i=0;i<5;i++){
		int xx=x+dir[i][0],yy=y+dir[i][1];
		if(xx>=0&&xx<n&&yy>=0&&yy<m)
			c+=fli[xx][yy];
	}
	return c%2;
}
int cal(){
	for(int i=1;i<n;i++){
		for(int j=0;j<m;j++){
			if(check(i-1,j)!=0)
				fli[i][j]=1;
		}
	}
	for(int i=0;i<m;i++)
		if(check(n-1,i)!=0)
			return -1;
	int res=0;
	for(int i=0;i<n;i++)
		for(int j=0;j<m;j++)
			res+=fli[i][j];
	return res;
}
int main(){
	while(~scanf("%d%d",&n,&m)){
		int ans=-1;
		for(int i=0;i<n;i++)
			for(int j=0;j<m;j++)
				scanf("%d",&mp[i][j]);
		for(int i=0;i<1<<m;i++){
			memset(fli,0,sizeof(fli));
			for(int j=0;j<m;j++)
				fli[0][m-j-1]=(i>>j)&1;
			int num=cal();
			if(num>0&&(ans<0||num<ans)){
				ans=num;
				memcpy(out,fli,sizeof(fli));
			}
		}
		if(ans==-1)
			printf("IMPOSSIBLE\n");
		else {
			for(int i=0;i<n;i++){
				for(int j=0;j<m-1;j++)
					printf("%d ",out[i][j]);
				printf("%d\n",out[i][m-1]);
			}
		}
	}
}

Find The Multiple  

#include<cstdio>
typedef long long ll;
int flag,n;
void dfs(ll t,int k){
	if(k==19||flag){
		return;	
	}	
	if(t%n==0){
		flag=1;
		printf("%lld\n",t);
		return;
	}
	dfs(t*10,k+1);
	dfs(t*10+1,k+1);
}
int main(){
	while(~scanf("%d",&n)&&n){
		flag=0;
		dfs(1,0);
	}
}

Prime Path

#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
int isprime[10005];
int vis[10005],d[10005];
int s,t;
void seive(){
	for(int i=2;i<=10000;i++){
		if(!isprime[i]){
			for(int j=i*2;j<=10000;j+=i)
				isprime[j]=1;
		}
	}
}
int bfs(){
	queue<int>q;
	int p[5];
	q.push(s);
	vis[s]=1;
	d[s]=0;
	while(!q.empty()){
		int v=q.front();
		q.pop();
		if(v==t)
			return d[t];
		p[0]=v%10;
		p[1]=v/10%10;
		p[2]=v/100%10;
		p[3]=v/1000;
		for(int i=0;i<4;i++){
			int te=p[i];
			for(int j=0;j<10;j++){
				if(j!=te){
				p[i]=j;
				int tem=p[3]*1000+p[2]*100+p[1]*10+p[0];
				if(!vis[tem]&&tem>=1000&&tem<10000&&!isprime[tem]){
					d[tem]=d[v]+1;
					vis[tem]=1;
					q.push(tem);
				}
				if(tem==t)
					return d[tem];
				}
			}
			p[i]=te;
		}
	}
	return -1;
}
int main(){
	int T;
	seive();
	scanf("%d",&T);
	while(T--){
		scanf("%d%d",&s,&t);
		memset(vis,0,sizeof(vis));
		memset(d,0,sizeof(d));
		int ans=bfs();
		if(ans==-1)
			printf("Impossible\n");
		else printf("%d\n",ans);
	} 
	return 0;
}

Shuffle'm Up

#include<cstdio>
#include<string>
#include<map>
#include<iostream>
using namespace std;
int main(){
	int T;
	scanf("%d",&T);
	for(int j=1;j<=T;j++){
		string s1,s2,s3;
		int n;
		scanf("%d",&n);
		cin>>s1>>s2>>s3;
		map<string,int>m;
		int ans=0;
		while(1){
			string s;
			for(int i=0;i<n;i++){
				s+=s2[i];
				s+=s1[i];
			}
			ans++;
			if(s==s3&&m[s]==0){
				printf("%d %d\n",j,ans);
				break;
			}
			if(m[s]==1&&s!=s3){
				printf("%d -1\n",j);
				break;
			}
			m[s]=1;
			s1.clear();
			s2.clear();
			for(int i=0;i<n;i++)
				s1+=s[i];
			for(int i=n;i<2*n;i++)
				s2+=s[i];
		}
	}
	return 0;
}

Pots

#include <iostream>
#include <cstdio>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <set>
#include <sstream>
using namespace std;
int a,b,c;
int tot=0,id[105*105],vis[105][105];
char op[][10]={"0","FILL(1)","FILL(2)","DROP(1)","DROP(2)","POUR(1,2)","POUR(2,1)"};
struct node{
	int no,k1,k2,op,step,pre;
	bool operator<(const node &c)const{
		return step>c.step;
	}
};
priority_queue<node>q;
node now,nxt;
vector<node>v;
void print(int i){
	int j=0;
	while(v[i].no){
		id[j++]=v[i].no;
		i=v[i].pre;
	}
	for(int k=j-1;k>=0;k--)
		printf("%s\n",op[v[id[k]].op]);
}
void bfs(){
	now.k1=now.k2=now.no=now.step=now.op=now.pre=0;
	vis[now.k1][now.k2]=1;
	q.push(now);
	v.push_back(now);
	while(!q.empty()){
		now=q.top();
		q.pop();
		if(now.k1==c||now.k2==c){
			printf("%d\n",now.step);
			print(now.no);
			return;
		}
		for(int i=1;i<=6;i++){
			if(i==1){
				nxt.k1=a;
				nxt.k2=now.k2;
			}
			else if(i==2){
				nxt.k1=now.k1;
				nxt.k2=b;
			}
			else if(i==3){
				nxt.k1=0;
				nxt.k2=now.k2;
			}
			else if(i==4){
				nxt.k1=now.k1;
				nxt.k2=0;
			}
			else if(i==5){
				if(now.k1+now.k2>b){
					nxt.k1=now.k1-(b-now.k2);
					nxt.k2=b;
				}
				else {
					nxt.k1=0;
					nxt.k2=now.k1+now.k2;
				}
			}
			else if(i==6){
				if(now.k1+now.k2>a){
					nxt.k2=now.k2-(a-now.k1);
					nxt.k1=a;
				}
				else {
					nxt.k2=0;
					nxt.k1=now.k2+now.k1;
				}
			}
			nxt.op=i;
			if(!vis[nxt.k1][nxt.k2]){
				vis[nxt.k1][nxt.k2]=1;
				tot++;
				nxt.no=tot;
				nxt.step=now.step+1;
				nxt.pre=now.no;
				q.push(nxt);
				v.push_back(nxt);
			}
		}
	}
	printf("impossible\n");
}
int main(){
	memset(vis,0,sizeof(vis));
	scanf("%d%d%d",&a,&b,&c);
	bfs();
}

Fire!

#include<bits/stdc++.h>
using namespace std;
const int inf=0x3f3f3f3f;
int dir[4][2]={{-1,0},{1,0},{0,1},{0,-1}};
int n,m,s,e;
bool vis[1005][1005];
int times[1005][1005];
int step[1005][1005];
char a[1005][1005];
struct node{
	int x,y;
	node(){};
	node(int _x,int _y):x(_x),y(_y){}
};
queue<node>q;
bool check(int x,int y){
	if(x<0||x>=n||y<0||y>=m)
		return false;
	if(vis[x][y])
		return false;
	return a[x][y]=='.';
}
void bfs_fire(){
	while(!q.empty()){
		node p=q.front();
		q.pop();
		for(int i=0;i<4;i++){
			int xx=p.x+dir[i][0];
			int yy=p.y+dir[i][1];
			if(check(xx,yy)){
				vis[xx][yy]=true;
				times[xx][yy]=times[p.x][p.y]+1;
				q.push(node(xx,yy));
			}
		}
	}
}
int bfs(int x,int y){
	step[x][y]=0;
	q.push(node(x,y));
	vis[x][y]=true;
	while(!q.empty()){
		node p=q.front();
		q.pop();
		if(p.x==0||p.x==n-1||p.y==0||p.y==m-1)
			return step[p.x][p.y]+1;
			
		for(int i=0;i<4;i++){
			int xx=p.x+dir[i][0];
			int yy=p.y+dir[i][1];
			if(check(xx,yy)&&step[p.x][p.y]+1<times[xx][yy]){
				step[xx][yy]=step[p.x][p.y]+1;
				vis[xx][yy]=true;
				q.push(node(xx,yy));
			}
		}
	}
	return -1;
}
int main(){
	ios::sync_with_stdio(false);
	int t;
	cin>>t;
	while(t--){
		cin>>n>>m;
		memset(times,inf,sizeof(times));
		memset(vis,false,sizeof(vis));
		for(int i=0;i<n;i++){
			for(int j=0;j<m;j++){
				cin>>a[i][j];
				if(a[i][j]=='J'){
					s=i;
					e=j;
				}
				if(a[i][j]=='F'){
					vis[i][j]=true;
					q.push(node(i,j));
					times[i][j]=0;
				}
			}
		}
		bfs_fire();
		while(!q.empty())
			q.pop();
		memset(vis,false,sizeof(vis));
		int ans=bfs(s,e);
		if(ans==-1)
			cout<<"IMPOSSIBLE\n";
		else cout<<ans<<"\n"; 
		
	}
	return 0; 
}

迷宫问题 

#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
struct node{
	int x,y;
};
node pre[8][8],t;
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}},a[8][8];
queue<node>q;
void bfs(){
	q.push({5,5});
	while(!q.empty()){
		int s=q.size();
		for(int i=0;i<s;i++){
			node t=q.front();
			q.pop();
			for(int j=0;j<4;j++){
				int x=t.x+dir[j][0],y=t.y+dir[j][1];
				if(a[x][y]==0){
					a[x][y]=1;
					pre[x][y]={t.x,t.y};
					q.push({x,y});
					if(t.x==1&&t.y==1)
						return;
				}
			}
		}
	}
}
int main(){
	memset(a,-1,sizeof(a));
	for(int i=1;i<=5;i++)
		for(int j=1;j<=5;j++)
			scanf("%d",&a[i][j]);
	bfs();
	node t={1,1};
	printf("(0, 0)\n");
	while(t.x!=5||t.y!=5){
		t=pre[t.x][t.y];
		printf("(%d, %d)\n",t.x-1,t.y-1);
	}
}

Oil Deposits

#include<bits/stdc++.h>
using namespace std;
char s[105][105];
int vis[105][105];
int dir[8][2]={{1,0},{-1,0},{0,-1},{0,1},{1,1},{1,-1},{-1,1},{-1,-1}};
int n,num,m;
void dfs(int x,int y){
	if(x<0||y<0||x>=n||y>=m||vis[x][y]||s[x][y]=='*')
		return;
	vis[x][y]=num;
	for(int i=0;i<8;i++){
		int xx=x+dir[i][0];
		int yy=y+dir[i][1];
		if(xx>=0&&yy>=0&&xx<n&&yy<m&&s[xx][yy]=='@')
			dfs(xx,yy);
	}
}
int main(){
	while(~scanf("%d%d",&n,&m)&&n){
		num=0;
		memset(vis,0,sizeof(vis));
		for(int i=0;i<n;i++)
			scanf("%s",s[i]);
		for(int i=0;i<n;i++)
			for(int j=0;j<m;j++){
				if(vis[i][j]==0&&s[i][j]=='@'){
					num++;
					dfs(i,j);
				}
			}
		printf("%d\n",num);
	}
}

Mine Sweeper

#include<cstdio>
#include<cstring>
using namespace std;
char mine[20][20];
char touch[20][20];
int dir[8][2]={{1,0},{-1,0},{0,1},{0,-1},{1,1},{1,-1},{-1,1},{-1,-1}};
int cnt[20][20];
int main(){
	int n;
	memset(cnt,0,sizeof(cnt));
	scanf("%d",&n);
	for(int i=0;i<n;i++)
		scanf("%s",mine[i]);
	for(int i=0;i<n;i++)
		scanf("%s",touch[i]);
	int f=0;
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			if(mine[i][j]=='*'&&touch[i][j]=='x')
				f=1;
			for(int k=0;k<8;k++){
				int x=i+dir[k][0],y=j+dir[k][1];
				if(x>=0&&y>=0&&x<n&&y<n){
					cnt[i][j]+=mine[x][y]=='*';
				}
			}
		}
	}
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			if(f&&mine[i][j]=='*')
				touch[i][j]='*';
			else if(touch[i][j]=='x')
				touch[i][j]=cnt[i][j]+'0';
		}
	}
	for(int i=0;i<n;i++)
		puts(touch[i]);
}

 

到不了的远方-
关注
专栏目录
[DFS]湖计算问题
qq_42008588的博客
08-18 208
经过反复观看以及啊哈算法的讲解，终于能看懂了dfs并自己能大致实现 数组越界问题 #include<iostream> using namespace std; int a[8][2]={{-1,-1},{-1,0},{-1,1},{0,-1},{0,1},{1,-1},{1,0},{1,1}}; int m,n; char land[105][105]; bool vis[105...
简单搜索app产品分析
YeaH_Chen的博客
08-27 4710
前言：最早接触到简单搜索大概是在17年的年底到18年的年初，当时的十分热门的抖音app推出了百万答题的活动，此时，简单搜索的语音搜索在此杀了出来，也就是这段时间开始了第一次认识到简单搜索，了解到简单搜索是百度旗下的产品。时以至此已经毕业，上个月有幸参加了百度的面试，正好是针对此产品的相关拓展联想，也就想来分析此款APP。 简单搜索官方体验地址 简单搜索看起来更像是百度搜索的缩减优化版本，...
二分图匹配 Hdu1150
Hatsune__Miku
10-16 527
注意 #include #include #include using namespace std; int map[105][105],match[105];; bool vis[105]; int n,m,k; bool dfs(int i){ for (int j=0;j<m;j++){ if (!vis[j]&&map[i][j]){ vis[j]=true;
基础搜索算法题解(N-R)
Tc的专栏
01-22 1958
搜索
0811 钟 区间第K大(kth)
weixin_33910434的博客
08-11 113
大模拟，这真是没什么好说的，一个一个时间往后走就可以了#include<iostream> #include<cstdio> #include<cstring> #define maxn 1000005 using namespace std; int col,n,sz; int f[105][105],a[maxn],c[...
【c++算法篇】--30分钟从0到精通讲解算法--搜索
贤鱼的博客
08-01 1705
一文掌握搜索算法
百度发布全新 AI 互动式搜索：百度简单搜索
简简单单Onlinezuozuo
10-17 1717
10月17日，百度世界大会2023即将开幕，此次活动将举办一场主论坛及七场分论坛百度简单搜索是百度通过大模型重构的第一个产品，也是首个A1互动式搜索一一简单搜索能听会看聪明懂你智能创作个性决策。
手机浏览器简单搜索ua标识
热门推荐
weixin_43434932的博客
06-17 1万+
根据自身体验，分享一下基于简单搜索的手机浏览器ua标识
Python实现简易搜索引擎
ccooppplus的博客
01-29 3658
Python实现简易搜索引擎 一、实验内容 实现对Python知识点与编程案例的搜索，建立Python知识点与案例资料库。对使用者输入的搜索词分词、去停用词、取关键词，纠正用户的错误输入，实现检索，记录每次的搜索词。 本地资料库没有搜索结果则利用爬虫在百度搜索爬取结果，做到每次搜索都有内容呈现给使用者，并实现图形用户界面与使用者交互。 二、实验目的 实现Python知识的搜索，建立Python知识...
基于<今日哈工大>新闻的简易搜索引擎
02-23
基于<今日哈工大>新闻的简易搜索引擎 #简易搜索引擎系统 ###基本概况 基于Python实现 面向新闻标题、正文 数据抓取自“今日哈工大”网（因为我砍后台没反爬虫） 新闻数量37251个 闲暇之余写的，没啥太高端的东西...
基于python开发的贴吧简易搜索引擎爬取
02-24
标题中的“基于python开发的贴吧简易搜索引擎爬取”是指使用Python编程语言开发的一款简单搜索引擎，其目标是抓取和处理百度贴吧的相关数据。这个搜索引擎爬虫可能是为了收集、分析或研究贴吧上的信息，例如热门话题...
python还原简易搜索引擎
08-22
在本项目中，“python还原简易搜索引擎”是一个使用Python编程语言实现的简单搜索工具，它能够模仿部分搜索引擎的功能，帮助用户在特定的数据集或文件中快速查找相关信息。这个项目非常适合初学者学习，因为它涉及到...
人工智能-项目实践-搜索引擎-基于Boost库的简易搜索引擎
02-26
本项目实践以"人工智能-项目实践-搜索引擎-基于Boost库的简易搜索引擎"为主题，旨在通过使用Boost库来构建一个基础的搜索引擎，帮助初学者理解搜索引擎的工作原理并掌握相关编程技巧。 首先，我们需要了解Boost库。...
人工智能-项目实践-搜索引擎-基于Nutch+ElasticSearch+MySQL+SSM的简易搜索引擎
02-25
标题中的“人工智能-项目实践-搜索引擎-基于Nutch+ElasticSearch+MySQL+SSM的简易搜索引擎”揭示了一个项目，旨在构建一个简易的搜索引擎，利用了人工智能的一些原理和技术。这个项目结合了多个开源工具，包括Nutch...
mmexport1728641832280.jpg
10-11
mmexport1728641832280.jpg
YOLOv5口罩检测 标注好的数据集+训练好的模型.zip
最新发布
10-11
这里是YOLOv5进行口罩佩戴检测的项目。里面包含了数据集（2000张数据集），源码和训练好的模型（可直接使用来检测）。如有问题可以私聊博主。
Microsoft Visio 2007 Guide.doc
10-11
Microsoft Visio 2007 Guide.doc
Microsoft Project 2007 Guide.doc
10-11
Microsoft Project 2007 Guide.doc
手边酒店yyf_hotel25.0.24安装更新一体包.zip
10-11
项目包含前后台完整源码，后端采用 PHP 语言开发，前台为小程序。 项目都经过严格调试，确保可以运行！ 具体项目介绍可查看博主文章 助力学习实践，提升编程技能，快来获取这份宝贵的资源吧！
html简易搜索引擎
04-09
HTML简易搜索引擎是一个基于HTML语言开发的简单搜索引擎，它可以帮助用户在指定的网页或网站中进行搜索并返回相关的结果。以下是HTML简易搜索引擎的基本实现方式： 1. 输入框：在搜索引擎的页面上，通常会有一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值