深度优先搜索

最新推荐文章于 2023-03-19 13:31:14 发布
最新推荐文章于 2023-03-19 13:31:14 发布
阅读量295 收藏
点赞数
分类专栏： 算法 文章标签： dfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LanFear0929/article/details/106306307
版权

  • 数据型DFS

P2036 [COCI2008-2009#2] PERKET

#include<bits/stdc++.h>
using namespace std;
const int N = 50;
const int INF = 0x3f3f3f3f;

int n,ans = INF;
int acid[N],sweet[N];

void DFS(int i,int x,int y){
	
	if(i > n){
		if(x == 1 && y == 0)return;
		ans = min(ans,abs(x - y));
		return;
	}
	
	DFS(i + 1,x * acid[i],y + sweet[i]);
	DFS(i + 1,x,y);
	
}

int main(){
	
	cin>>n;
	for(int i = 1;i <= n;i++)cin>>acid[i]>>sweet[i];
	
	DFS(1,1,0);
	
	cout<<ans<<endl; 
}

H1016 素数环(DFS+素数筛)

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#define ms(a,b) memset(a,b,sizeof(a))
using namespace std;
const int N = 51;

int n,cnt;
int prime[N];
bool vis[N];
int ans[N];

void prime_set(){//素数筛 
	
	for(int i = 2;i <= sqrt(N);i++)
		if(!prime[i])for(int j = 2;i * j <= N;j++)prime[i * j] = 1;
		
	prime[1] = 0,vis[1] = true;
}

void DFS(int step){
	
	//出口 
	if(prime[ans[step - 1] + ans[step - 2]])return;
	if(step == n + 1 && prime[ans[n] + 1])return;
	
	//结束输出 
	if(step == n + 1){
		for(int i = 1;i < n;i++)cout<<ans[i]<<" ";
		cout<<ans[n]<<endl;
		
	}
	
	//搜索 
	for(int i = 2;i <= n;i++){
		if(!vis[i]){
			
			vis[i] = true;
			ans[step] = i;//赋值 
			DFS(step + 1);
			vis[i] = false;//回溯 
		}
	}
}

int main(){
	
	prime_set();
	
	while(~scanf("%d",&n)){
		
		ms(vis,false);
		
		cout<<"Case "<<++cnt<<":"<<endl;
		
		ans[1] = 1;
		if(n == 1)cout<<"1"<<endl;
		else DFS(2);
		
		cout<<endl;
	}
	
	return 0;
}

H1258 Sum It Up

#include<iostream>
#include<cstring>
#include<algorithm>
#define ms(a,b) memset(a,b,sizeof(a))
using namespace std;
const int N = 15;
//去重 难点 
int t,n;
int num[N],ans[N],flag;
bool vis[N];

void DFS(int place,int x,int sum){
	
	if(sum == t){
		
		flag = 1;
		if(x == 1)cout<<ans[1]<<endl;
		else{
			for(int i = 1;i < place - 1;i++)cout<<ans[i]<<"+";
			cout<<ans[place - 1]<<endl;
		}
		return;
	}
	
	if(x > n || sum > t)return;//写在前面的话可能正好 x == n + 1 这种情况会漏掉 
	
	ans[place] = num[x];
	DFS(place + 1,x + 1,sum + num[x]);
	
	while(x < n && num[x] == num[x + 1])x++;//??????
	DFS(place,x + 1,sum); //???? 真没看懂 
	
}

int main(){
	
	while(true){
		
		flag = 0;
		ms(vis,false);
		
		cin>>t>>n;
		if(!n)break;
		for(int i = 1;i <= n;i++)cin>>num[i];
		
		cout<<"Sums of "<<t<<":"<<endl;
		DFS(1,1,0);
		
		if(flag == 0)cout<<"NONE"<<endl;
	}
	return 0;
}

P2392 kkksc03考前临时抱佛脚

#include<bits/stdc++.h>
using namespace std;
const int N = 50;
const int INF = 0x3f3f3f3f;

int n,ans = INF;
int acid[N],sweet[N];

void DFS(int i,int x,int y){
	
	if(i > n){
		if(x == 1 && y == 0)return;
		ans = min(ans,abs(x - y));
		return;
	}
	
	DFS(i + 1,x * acid[i],y + sweet[i]);
	DFS(i + 1,x,y);
	
}

int main(){
	
	cin>>n;
	for(int i = 1;i <= n;i++)cin>>acid[i]>>sweet[i];
	
	DFS(1,1,0);
	
	cout<<ans<<endl; 
}

P2404 自然数的拆分问题

#include<bits/stdc++.h>
using namespace std;
const int N = 10000;

int n;
int num[N] = {1};

void print(int x){
	for(int i = 1;i < x;i++)cout<<num[i]<<"+";
	cout<<num[x]<<endl;
}

int DFS(int x,int sum){
	
	for(int i = num[x - 1];i <= sum;i++)
		if(i < n){
			num[x] = i;
			sum-= i;
			if(!sum)print(x);
			else DFS(x + 1,sum);
			sum += i;
		}
}

int main(){
	cin>>n;
	DFS(1,n);
	return 0;
}

P2392 kkksc03考前临时抱佛脚

#include<bits/stdc++.h>
using namespace std;
const int N = 50;
const int INF = 0x3f3f3f3f;

int s1,s2,s3,s4;
int l,r,ans,minn;

int work[N][5];
int s[N];

void DFS(int x,int i){
	
	if(x > s[i]){
		minn = min(minn,max(l,r));
		return;
	}
	
	l += work[x][i];
	DFS(x + 1,i);
	l -= work[x][i];
	
	r += work[x][i];
	DFS(x + 1,i);
	r -= work[x][i];
}

int main(){
	
	cin>>s[1]>>s[2]>>s[3]>>s[4];
	
	for(int i = 1;i <= 4;i++){
		l = 0;
		r = 0;
		minn = INF;
		
		for(int j = 1;j <= s[i];j++)cin>>work[j][i];
		DFS(1,i);
		ans += minn;
	}
	
	cout<<ans; 
}

  • 地图型DFS

P1605 迷宫

#include<bits/stdc++.h>
using namespace std;
const int N = 10;

int n,m,t,sx,sy,fx,fy,ans = 0;
int a,b;
int table[N][N];
int vis[N][N];

int dir[][2] = {{0,1},{1,0},{0,-1},{-1,0}};

int check(int x,int y){
	if(x < 1 || x > n)return 0;
	if(y < 1 || y > m)return 0;
	return 1;
}

void DFS(int x,int y){
	//cout<<x<<" "<<y<<endl;
	//if(!check(x,y))return;
	
	if(x == fx && y == fy){
		ans++;
		return;
	}
	
	for(int i = 0;i <= 3;i++)
		if(table[x + dir[i][0]][y + dir[i][1]] == 1 && !vis[x + dir[i][0]][y + dir[i][1]]){
			vis[x][y] = 1;//是给走过的打上标记 
			DFS(x + dir[i][0],y + dir[i][1]);
			vis[x][y] = 0;
		}
	//如果没有障碍并且不是自己走过的，就进一步搜索，把自己走过的路打上标记，返回时，再将标记还原；
}

int main(){
	cin>>n>>m>>t;
	cin>>sx>>sy;
	cin>>fx>>fy;
	
	for(int i = 1;i <= n;i++)
		for(int j = 1;j <= m;j++)table[i][j] = 1;
	//有一个zz把 table[i][j] = 1 写成table[i][j] == 1  然后查了半个小时代码  没错是我 
	for(int i = 1;i <= t;i++){
		cin>>a>>b;
		table[a][b] = 0;
	}
		
	DFS(sx,sy);
	
	cout<<ans;
	return 0;
}

P1596 [USACO10OCT]Lake Counting S

#include<bits/stdc++.h>
using namespace std;
const int N = 200;

int n,m,ans;
char table[N][N];
bool vis[N][N];

int dir[][2] = {{0,1},{1,0},{0,-1},{-1,0},{1,1},{1,-1},{-1,-1},{-1,1}};

int check(int x,int y){
	if(x < 1 || x > n)return 0;
	if(y < 1 || y > m)return 0;
	return 1;
}

void DFS(int x,int y){
	
	table[x][y] = '.';
	
	for(int i = 0;i <= 7;i++)
		if(table[x + dir[i][0]][y + dir[i][1]] == 'W' && !vis[x + dir[i][0]][y + dir[i][1]]){
			vis[x][y] = 1;//是给走过的打上标记 
			DFS(x + dir[i][0],y + dir[i][1]);
			vis[x][y] = 0;
		}
}

int main(){
	cin>>n>>m;
			
	for(int i = 1;i <= n;i++)
		for(int j = 1;j <= m;j++)cin>>table[i][j];
	
	for(int i = 1;i <= n;i++)
		for(int j = 1;j <= m;j++)if(table[i][j] == 'W'){
			ans++;
			DFS(i,j);
		}
				
	cout<<ans;
	return 0;
}

P1219 八皇后问题

#include<bits/stdc++.h>
#define ms(a,b) memset(a,b,sizeof(a))
using namespace std;
const int N = 100;
//好吧这种方法不太行 必须要把地图存成四个数组 或者一个二维是4的数组才行 
//这样能记录 四条对角线的状态
 
int n,cnt;

int table[N][N];
int vis[N][N];
int ans[N],b[N],c[N],d[N];

//ans数组表示的是行；
//b数组表示的是列；
//c表示的是左下到右上的对角线；
//d表示的是左上到右下的对角线；

int check(int x,int y){
	if(x < 1 || x > n)return 0;
	if(y < 1 || y > n)return 0;
	
	return 1;
}


void paint(int x,int y){
	
	int a,b;
	
	a = min(n - x,n - y);
	b = min(x - 1,y - 1);
	
	for(int i = 1;i <= n;i++)vis[x][i] == true;
	for(int i = 1;i <= n;i++)vis[i][y] == true;
	for(int i = 1;i <= a;i++)vis[x + i][y + i] == true;
	for(int i = 1;i <= b;i++)vis[x - i][y - i] == true;
	
}

void DFS(int x){
	
	if(x > n){
		cnt++;
		
		if(cnt <= 3){
			for(int i = 1;i < n;i++)cout<<ans[i]<<" ";
			cout<<ans[n]<<endl;
		}
			
		return;
	}
	
	for(int i = 1;i <= n;i++){//尝试所有可能 
		if(!b[i] && !c[x + i] && !d[x - i + n]){
			
			ans[x] = i;
			b[i] = 1;
			c[x + i] = 1;
			d[x - i + n] = 1;
			
			DFS(x + 1);
			
			b[i] = 0;
			c[x + i] = 0;
			d[x - i + n] = 0;//三步回溯 
			
		}
	}
}

int main(){
	cin>>n; 
	
	DFS(1); 
	cout<<cnt;
	return 0;
}

H1045 Fire Net

#include<bits/stdc++.h>
#define ms(a,b) memset(a,b,sizeof(a))
using namespace std;
const int N = 15;

int n,ans;
char table[N][N];

int dir[][2] = {{0,1},{1,0},{0,-1},{-1,0}};

int check(int x,int y){
	
	if(table[x][y] != '.')return 0;
	
	int dx,dy;
	for(int i = 0;i < 4;i++){
		
		dx = x + dir[i][0];
		dy = y + dir[i][1];
		
		while(true){
			if(dx < 1 || dx > n || dy < 1 || dy > n || table[dx][dy] == 'X')break;
			else if(table[dx][dy] == '1')return 0;
			
			dx += dir[i][0], dy += dir[i][1];
		}
	} 
	return 1;
}

void DFS(int num){
	
	ans = max(ans,num);
	
	for(int i = 1;i <= n;i++){
		for(int j = 1;j <= n;j++){
			if(check(i,j)){
				
				table[i][j] = '1';
				DFS(num + 1);
				table[i][j] = '.';
				
			}
		}
	}	
}

int main(){
	
	while(scanf("%d",&n) && n){
	
		ans = 0;
		for(int i = 1;i <= n;i++)for(int j = 1;j <= n;j++)cin>>table[i][j];
		DFS(0);
		cout<<ans<<endl;
		
	}
	
	return 0;
}

H1010 Tempter of the Bone

#include<cstring>
#include<iostream>
#include<cmath>
#define ms(a,b) memset(a,b,sizeof(a))
#define FAST ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
using namespace std;
const int N = 15;
//奇偶剪枝

int n,m,t,sx,sy,fx,fy,ans;
char table[N][N];
bool vis[N][N];

int dir[][2] = {{0,1},{1,0},{0,-1},{-1,0}};

void DFS(int x,int y,int step){
	
	//出口 
	if(x < 1 || x > n)return;
	if(y < 1 || y > m)return;
	
	if(table[x][y] == 'D' && step == t){
		ans = 1;
		return;
	}
	
	//剪枝 光剪枝还不够... 
	if(abs(x - fx) + abs(y - fy) > t - step)return;//步数不够
	if((t - step) % 2 != (abs(x - fx) + abs(y - fy)) % 2)return;//奇偶性不同 
	
	//搜索 
	vis[x][y] = true; 
	for(int i = 0;i <= 3;i++){
		
		int dx,dy;
		dx = x + dir[i][0],dy = y + dir[i][1];
		
		if(table[dx][dy] != 'X' && !vis[dx][dy] && !ans){//!ans 表示如果成功了就直接停止搜素 
			
			DFS(dx,dy,step + 1);
			vis[dx][dy] = false;
		}
	}
}
		

int main(){
	
	FAST;
	
	while(cin>>n>>m>>t && n && m && t){
	
	//初始化 
	ans = 0;
	ms(vis,false);
	 
	for(int i = 1;i <= n;i++)
		for(int j = 1;j <= m;j++){
			
			cin>>table[i][j];
			if(table[i][j] == 'S')sx = i,sy = j;
			if(table[i][j] == 'D')fx = i,fy = j;
			
		}
		
	//搜索 
	DFS(sx,sy,0);
	
	//输出 
	if(ans)cout<<"YES"<<endl;
	else cout<<"NO"<<endl;
	
	}
	return 0;
}

H1035 Robot Motion

#include<iostream>
#include<cstring>
#define ms(a,b) memset(a,b,sizeof(a))
using namespace std;
const int N = 15;

int n,m,start;
int step,extra; 
char table[N][N];	
int vis[N][N];

//int dir[][2] = {{0,1},{1,0},{0,-1},{-1,0}};

int check(int x,int y){
	if(x < 1 || x > n)return 0;
	if(y < 1 || y > m)return 0;
	return 1;
}

void DFS(int x,int y){
	
	if(!check(x,y)){
		cout<<step<<" step(s) to exit"<<endl;
		return;
	}
	
	if(vis[x][y] == 1)extra++;
	
	if(vis[x][y] == 2){
		cout<<step - 2 * extra<<" step(s) before a loop of "<<extra<<" step(s)"<<endl;
		return;
	}
	
	step++;
	vis[x][y]++;
	
	if(table[x][y] == 'N')DFS(x - 1,y);
	if(table[x][y] == 'S')DFS(x + 1,y);
	if(table[x][y] == 'W')DFS(x,y - 1);
	if(table[x][y] == 'E')DFS(x,y + 1);
}

int main(){
	
	while(scanf("%d %d",&n,&m) && n != 0 && m != 0){
		
		scanf("%d",&start);
		step = 0,extra = 0;
		ms(vis,0);
		for(int i = 1;i <= n;i++)for(int j = 1;j <= m;j++)cin>>table[i][j];
		DFS(1,start);
		
	}
	
	return 0;
}

我死会儿…

Cyber苦行者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
P2036 [COCI2008-2009#2] PERKET 【DFS】
ln2037的博客
09-16 419
题目描述 Perket 是一种流行的美食。为了做好 Perket，厨师必须谨慎选择食材，以在保持传统风味的同时尽可能获得最全面的味道。你有 nnn 种可支配的配料。对于每一种配料，我们知道它们各自的酸度 sss 和苦度 bbb。当我们添加配料时，总的酸度为每一种配料的酸度总乘积；总的苦度为每一种配料的苦度的总和。 众所周知，美食应该做到口感适中，所以我们希望选取配料，以使得酸度和苦度的绝对差最小。 另外，我们必须添加至少一种配料，因为没有任何食物以水为配料的。 输入格式 第一行一个整数 nnn，表示可供选用
洛谷刷题P2036 [COCI2008-2009#2] PERKET
weixin_74205160的博客
07-13 182
洛谷刷算法
洛谷P2036 [COCI2008-2009#2] PERKET
STATICHIT静砸的博客
01-13 617
题目描述 Perket 是一种流行的美食。为了做好 Perket，厨师必须谨慎选择食材，以在保持传统风味的同时尽可能获得最全面的味道。你有nn种可支配的配料。对于每一种配料，我们知道它们各自的酸度ss和苦度bb。当我们添加配料时，总的酸度为每一种配料的酸度总乘积；总的苦度为每一种配料的苦度的总和。 众所周知，美食应该做到口感适中，所以我们希望选取配料，以使得酸度和苦度的绝对差最小。 另外，我们必须添加至少一种配料，因为没有任何食物以水为配料的。 输入格式 第一行一个整数nn，表示可供...
洛谷P2036 PERKET
有模有样
01-14 306
题目： Perket 是一种流行的美食。为了做好 Perket，厨师必须谨慎选择食材，以在保持传统风味的同时尽可能获得最全面的味道。你有 nn 种可支配的配料。对于每一种配料，我们知道它们各自的酸度 ss 和苦度 bb。当我们添加配料时，总的酸度为每一种配料的酸度总乘积；总的苦度为每一种配料的苦度的总和。 众所周知，美食应该做到口感适中，所以我们希望选取配料，以使得酸度和苦度的绝对差最小。 另外，我们必须添加至少一种配料，因为没有任何食物以水为配料的。 输入格式 第一行一个整数 nn，表示可供选用的食材种类
洛谷-P2036 [COCI2008-2009#2] PERKET
weixin_43098069的博客
07-23 149
题目描述 Perket 是一种流行的美食。为了做好 Perket，厨师们必须小心选择配料，以便达到更好的口感。你有N种可支配的配料。对于每一种配料，我们知道它们各自的酸度SS和甜度BB。当我们添加配料时，总的酸度为每一种配料的酸度总乘积；总的甜度为每一种配料的甜度的总和。 众所周知，美食应该口感适中；所以我们希望选取配料，以使得酸度和甜度的绝对差最小。 另外，我们必须添加至少一种配料，因为没有美食是以白水为主要配料的。 输入格式 第一行包括整数NN，表示可支配的配料数。 接下来NN行...
C#深度优先搜索算法
08-30
C#深度优先搜索算法 C#深度优先搜索算法是一种常用的搜索算法，广泛应用于图形搜索、网络搜索、游戏开发等领域。深度优先搜索算法的主要思想是从起点开始，沿着图形的边缘深入搜索，直到找到目标节点为止。下面是...
C++深度优先搜索的实现方法
12-26
本文实例讲述了图的遍历中深度优先搜索的C++实现方法，是一种非常重要的算法，具体实现方法如下： 首先，图的遍历是指从图中的某一个顶点出发，按照某种搜索方法沿着图中的边对图中的所有顶点访问一次且仅访问一次。...
迷宫问题c语言 深度优先搜索
07-23
迷宫问题c语言 深度优先搜索
[COCI2008-2009#2] PERKET
qq_52079442的博客
03-19 139
P2036 [COCI2008-2009#2] PERKET 暴力枚举
常见DFS数据分布分析
枫之谷-技术园
11-06 1387
该文档为实实在在的原创文档，转载请注明：http://blog.sina.com.cn/s/blog_8c243ea30101litb.html   类型 详细 备注 该文档是几个典型分布式文件系统的总结，重点在于各个分布式文件系统的数据分布方式分析，顺带介绍系统架构及其优点缺点。     相关描述 ²  其他相关文档请参考新浪博客http://blog.si
P2036 [COCI2008-2009#2] PERKET
KQYaili的博客
08-17 218
练练手
题解洛谷P2392（c++解法）kkksc03考前临时抱佛脚
dogcat987的博客
05-10 475
输入N个数，将这N个数能够分成两组，使得两组总数最接近就是本题的解法。可以用搜索，递归，也可以用01背包。由于我太弱……所以用的深搜…… #include<cstdio> #include<algorithm> #include<cstring> #define MAXN 25 #define MAXM 610 using namespace std; int s1,s2,s3,s4; inline int read() { int date=0,w=1;char c=
[数据结构]图的深度优先搜索（DFS）和广度优先搜索（BFS）（通俗易懂）
IT博客-wusheng_z
04-15 565
一、深度优先搜索（DFS，Depth First Search） 深度优先搜索的主要思想：首先从一个未走过的顶点作为起始顶点，沿当前顶点的边走到未访问过的顶点；当没有被访问过的顶点时，则回到上一个顶点，继续访问别的未被访问过的顶点，直到所有的顶点都被访问过。（不撞南墙不回头） DFS遍历图解过程如下： 1、DFS邻接矩阵核心代码实现（可以链表实现，以下是数组实现）： bool boo...
全排列——dfs（数据型）初步详解
qq_57030927的博客
03-29 212
输入 n,输出1-n的全排列 0<n<10 #include <iostream> using namespace std; int n; int a[10]; bool vis[10]; //避免重复搜索，标记是否已搜过(默认为0) void dfs(int step)//深度，想象站在放置数字卡片的第step个盒子面前 { if(step==n+1)//结束搜索 { for(int i=1;i<=n;i++) ...
深度优先搜索 matlab
最新发布
05-02
深度优先搜索（Depth First Search，DFS）是种常用的图遍历算法，用于遍历或搜索图或树的数据结构。在深度优先搜索中，从起始节点开始，沿着一条路径尽可能深入地探索，直到无法继续为止，然后回溯到前一个节点，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值