DFS&BFS

最新推荐文章于 2023-02-06 14:35:45 发布
最新推荐文章于 2023-02-06 14:35:45 发布
阅读量145 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42792383/article/details/84184670
版权

HOJ 1440 - Knight Moves

#include<iostream>
#include<cstring>
#include<queue>
#include<cstdio>
using namespace std;
int dir[8][2] = {1,2,2,1,2,-1,1,-2,-1,-2,-2,-1,-2,1,-1,2};
struct node {
    int x,y;
    int step;
}start,end,tmp,nxt;
int vst[9][9];//数组越界
queue <node> q;
int bfs(){
   while(!q.empty()) q.pop();
   memset(vst,0,sizeof(vst));
   vst[start.x][start.y]=1;
   q.push(start);
   while(!q.empty()){
        tmp=q.front();
        q.pop();
        if(tmp.y==end.y&&tmp.x==end.x)
                return tmp.step;
        for(int i=0;i<8;i++){
            nxt.x=tmp.x+dir[i][0];
            nxt.y=tmp.y+dir[i][1];
            if(nxt.x>=0&&nxt.x<=7&&nxt.y>=0&&nxt.y<=7&&!vst[nxt.x][nxt.y]){
                 vst[nxt.x][nxt.y] = 1;
                 nxt.step=tmp.step+1;
                 q.push(nxt);
            }
        }
   }
   return 0;
}
int main()
{
    char src[30],dst[30];
    while(scanf("%s%s",&src,&dst)!=EOF){
        start.x = src[0] - 'a';//范围为[0,7]
        start.y = src[1] - '1';
        end.x = dst[0] - 'a';
        end.y = dst[1] - '1';
        int ans=bfs();
        printf("To get from %s to %s take %d knight moves.\n",src,dst,ans);
    }
}

HOJ 1797 - Red and Black
BFS版本

#include<iostream>
#include<cstdio>
#include<queue>
using namespace std;
const int maxn=100;
struct data{
	int x,y;
};
int dir[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
int g[maxn][maxn];
int RedandBlack(data start,int m,int n)
{
	queue<data> q;
	int i,cnt=0;
	data p,f;
	while(!q.empty())       //清空队列
	{
		q.pop();
	}
	q.push(start);         //初始状态入队
	g[start.x][start.y]=1;
	cnt++;
	while(!q.empty())
	{
		p=q.front();
		q.pop();
		for(i=0;i<4;i++)              //状态p的转移状态入队
		{
			f.x=p.x+dir[i][0];
			f.y=p.y+dir[i][1];
			if(f.x<0||f.y<0||f.x>m-1||f.y>n-1)    //边界条件判断
				continue;
			if(g[f.x][f.y]==0)
			{
				q.push(f);
				g[f.x][f.y]=1;
				cnt++;
			}
		}
	}
	return cnt;
}
int main()
{
	int m,n,i,j;
	char x;
	data start;
	while(scanf("%d %d",&n,&m)==2&&m&&n)
	{
		getchar();
		for(i=0;i<m;i++)
		{
			for(j=0;j<n;j++)
			{
				scanf("%c",&x);
				if(x=='.')
				{
					g[i][j]=0;
				}
				else if(x=='#')
				{
					g[i][j]=1;
				}
				else
				{
					g[i][j]=0;
					start.x=i;
					start.y=j;
				}
			}
			getchar();
		}
		printf("%d\n",RedandBlack(start,m,n));
	}
	return 0;
}

DFS递归版

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int maxn=100;
int g[maxn][maxn];
struct node{
    int x,y;
}start,cur,nxt;
int cnt;
int dir[4][2]={1,0,-1,0,0,1,0,-1};
int dfs(node s,int m,int n){
    g[s.x][s.y]=1;
    cnt++;
    for(int i=0;i<4;i++){
        nxt.x=s.x+dir[i][0];
        nxt.y=s.y+dir[i][1];
        if(nxt.x<0||nxt.y<0||nxt.x>m-1||nxt.y>n-1) continue;
        if(g[nxt.x][nxt.y]==0)
            dfs(nxt,m,n);
    }
    return cnt;
}
int main()
{
    char x;
    int m,n;
    while(scanf("%d%d",&n,&m)!=EOF&&m&&n){
        getchar();
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                scanf("%c",&x);
                    if(x=='.')
				{
					g[i][j]=0;
				}
				else if(x=='#')
				{
					g[i][j]=1;
				}
				else
				{
					g[i][j]=0;
					start.x=i;
					start.y=j;
				}
            }
            getchar();
        }
        cnt=0;
        int ans=dfs(start,m,n);
        printf("%d\n",ans);
    }
}

DFS非递归版

#include<iostream>
#include<cstdio>
#include<cstring>
#include<stack>
using namespace std;
const int maxn=100;
int g[maxn][maxn];
struct node{
    int x,y;
}start,cur,nxt;
int cnt;
int dir[4][2]={1,0,-1,0,0,1,0,-1};
int dfs(int m,int n){
    stack<node> q;
    int cnt=0;
    while(!q.empty()) q.pop();
    q.push(start);
    g[start.x][start.y]=1;
    cnt++;
    while(!q.empty()){
        cur=q.top();
         q.pop();
        for(int i=0;i<4;i++){
            nxt.x=cur.x+dir[i][0];
            nxt.y=cur.y+dir[i][1];
            if(nxt.x<0||nxt.y<0||nxt.x>m-1||nxt.y>n-1) continue;
            if(g[nxt.x][nxt.y]==0){
                q.push(nxt);
                g[nxt.x][nxt.y]=1;
                cnt++;
            }
        }
    }
    return cnt;
}
int main()
{
    char x;
    int m,n;
    while(scanf("%d%d",&n,&m)!=EOF&&m&&n){
        getchar();
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                scanf("%c",&x);
                    if(x=='.')
				{
					g[i][j]=0;
				}
				else if(x=='#')
				{
					g[i][j]=1;
				}
				else
				{
					g[i][j]=0;
					start.x=i;
					start.y=j;
				}
            }
            getchar();
        }
        int ans=dfs(m,n);
        printf("%d\n",ans);
    }
}

UVA 372 Oil Deposits
DFS 递归版

#include<iostream>
#include<cstdio>
#include<cstring>
#include<stack>
using namespace std;
const int maxn=100;
int cnt;
int dir[8][2]={1,0,-1,0,0,1,0,-1,1,1,1,-1,-1,1,-1,-1};
char map[105][105];
bool vis[105][105];
int m,n;
void dfs(int x,int y){
    for(int i=0;i<8;i++){
        int dx=x+dir[i][0];
        int dy=y+dir[i][1];
        if(dx<0||dy<0||dx>m-1||dy>n-1||map[dx][dy]!='@'||vis[dx][dy]) continue;
        vis[dx][dy]=1;
        dfs(dx,dy);
    }
}
int main()
{
    while(scanf("%d%d",&m,&n)!=EOF&&m&&n){
        getchar();
       memset(vis,0,sizeof(vis));
		for(int i=0 ;i<m;i++){
			gets(map[i]);
		}
		int cnt = 0;
		for(int i=0 ;i<m ;i++){
			for(int j=0 ;j<n ;j++){
				if(map[i][j]=='@'&&!vis[i][j]){
					cnt++;
					dfs(i,j);
				}

			}
		}
		printf("%d\n",cnt);
    }
    return 0;
}

DFS非递归版

#include<iostream>
#include<cstdio>
#include<cstring>
#include<stack>
using namespace std;
const int maxn=100;
struct node{
    int x,y;
}start,cur,nxt;
int dir[8][2]={1,0,-1,0,0,1,0,-1,1,1,1,-1,-1,1,-1,-1};
char map[105][105];
bool vis[105][105];
int m,n;
void dfs(int x,int y){
    stack<node> q;
    while(!q.empty()) q.pop();
    start.x=x;
    start.y=y;
    q.push(start);
    vis[start.x][start.y]=1;
    while(!q.empty()){
        cur=q.top();
        q.pop();
        for(int i=0;i<8;i++){
            nxt.x=cur.x+dir[i][0];
            nxt.y=cur.y+dir[i][1];
            if(nxt.x<0||nxt.y<0||nxt.x>m-1||nxt.y>n-1||map[nxt.x][nxt.y]!='@'||vis[nxt.x][nxt.y]) continue;
            if(vis[nxt.x][nxt.y]==0){
                q.push(nxt);
                vis[nxt.x][nxt.y]=1;
            }
        }
    }
}
int main()
{
    char x;
    while(scanf("%d%d",&m,&n)!=EOF&&m&&n){
        getchar();
       memset(vis,0,sizeof(vis));
		for(int i=0 ;i<m;i++){
			gets(map[i]);
		}
		int cnt = 0;
		for(int i=0 ;i<m ;i++){
			for(int j=0 ;j<n ;j++){
				if(map[i][j]=='@'&&!vis[i][j]){
					cnt++;
					dfs(i,j);
				}

			}
		}
		printf("%d\n",cnt);
    }
    return 0;
}

DFS非递归升级版

#include<iostream>
#include<cstdio>
#include<cstring>
#include<stack>
using namespace std;
const int maxn=100;
struct node{
    int x,y;
}start,cur,nxt;
int dir[8][2]={1,0,-1,0,0,1,0,-1,1,1,1,-1,-1,1,-1,-1};
char map[105][105];
bool vis[105][105];
int m,n;
void dfs(int x,int y){
    stack<node> q;
    while(!q.empty()) q.pop();
    start.x=x;
    start.y=y;
    q.push(start);
    vis[start.x][start.y]=1;
    while(!q.empty()){
        cur=q.top();
        q.pop();
        for(int i=0;i<8;i++){
            nxt.x=cur.x+dir[i][0];
            nxt.y=cur.y+dir[i][1];
            if(nxt.x<0||nxt.y<0||nxt.x>m-1||nxt.y>n-1||map[nxt.x][nxt.y]!='@'||vis[nxt.x][nxt.y]) continue;
            if(vis[nxt.x][nxt.y]==0){
                q.push(nxt);
                vis[nxt.x][nxt.y]=1;
            }
        }
    }
}
int main()
{
    char x;
    while(scanf("%d%d",&m,&n)!=EOF&&m&&n){
        getchar();
       for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                scanf("%c",&x);
                map[i][j]=x;
                    if(x=='@')
				{
					vis[i][j]=0;
				}
				else
					vis[i][j]=1;
            }
            getchar();
        }
		int cnt = 0;
		for(int i=0 ;i<m ;i++){
			for(int j=0 ;j<n ;j++){
				if(vis[i][j]==0){
					cnt++;
					dfs(i,j);
				}

			}
		}
		printf("%d\n",cnt);
    }
    return 0;
}

HDU2553-N皇后问题

#include<iostream>
#include<cstdio>
using namespace std;
int tot;
int res[10];

void search(int cur,int n)
{
    if(cur==n) tot++;
    else
    {
        for(int i=0;i<n;i++)
        {
            int flag=1;
            res[cur]=i;
            for(int j=0;j<cur;j++)
                if(res[cur]==res[j]||cur-res[cur]==j-res[j]||cur+res[cur]==j+res[j]){
                flag=0;
                break;
            }
            if(flag) search(cur+1,n);
        }
    }
}

int main()
{

    int a[11];
    for(int i=1;i<=10;i++)
    {
        tot=0;
        search(0,i);
        a[i]=tot;
    }
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        if(n==0) break;
        printf("%d\n",a[n]);
    }
    return 0;
}

HOJ 2979 - Escape from Pyramids

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
using namespace std;
struct node
{
    int x,y,step;
}start,cur,nxt,end[110];
int vis[110][110];
int dx[6]={-1,-1,0,0,1,1};
int dy[6]={-1,0,-1,1,0,1};
int bfs(int count,int h){
    queue<node> q;
    while(!q.empty()) q.pop();
    start.step=0;
    q.push(start);
    vis[start.x][start.y]=1;
    while(!q.empty()){
        cur=q.front();
        q.pop();
        for(int i=0; i<count; i++)
        {
            if(cur.x==end[i].x&&cur.y==end[i].y)
              {
                  return cur.step;
              }
        }
        for(int i=0;i<6;i++){
            nxt.x=cur.x+dx[i];
            nxt.y=cur.y+dy[i];
            if(nxt.x<1||nxt.y<1||nxt.x>h||nxt.y>nxt.x||vis[nxt.x][nxt.y]) continue;
                 vis[nxt.x][nxt.y] = 1;
                 nxt.step=cur.step+1;
                 q.push(nxt);
        }
    }
    return 0;
}
int main()
{
    int h,t;
    char x;
    int cases=0;
     while(scanf("%d%d",&h,&t)!=EOF)
    {
        int cnt=0;
        cases++;
        memset(vis,0,sizeof(vis));
        for (int i=1; i<=h; i++)
        {
            for (int j=1; j<=i; j++)
            {
                scanf(" %c",&x);
                if(x=='S')
                {
                    start.x=i;
                    start.y=j;
                }
                else if(x=='*')  vis[i][j]=1;
                else if(x=='D')
                {
                    end[cnt].x=i;
                    end[cnt].y=j;
                    cnt++;
                }
                else  vis[i][j]=0;
            }
        }
        int ans=bfs(cnt,h);
        printf("Maze #%d :\n",cases);
        if(ans>t&&ans!=0) printf("Oh No, I'm afraid that you don't have enough time to escape!\n");
        else printf("Hurry up, You need %d minutes to escape!\n",ans);
    }
    return 0;
}

HDU 1016 素数环问题
回溯法解决问题

#include<stdio.h>  
#include <string.h>  
  
#define M 40  
  
int isPrime[M];素数表,下标为素数的置为1,否则0  
int vis[M>>1];// vis 标识 1-n,是否被选  
int res[M>>1];// 存储解向量  
  
int cnt;// 测试样例个数  
  
void prime()//求出1-40的所有素数  
{  
    int i, j;  
    for(i=1; i<M; ++i)  
    {  
        int ok = 1;  
        for(j=2; j*j<=i; ++j)  
        {  
            if(i%j == 0)  
            {  
                ok = 0;  
                break;  
            }  
        }  
        if(ok)  
            isPrime[i]=1;  
  
    }  
}  
  
void dfs(int cur, int n)  
{  
    int i;  
    if(cur == n && isPrime[res[n-1] + res[0]])//别忘了测试边界，最后一个和第一个数 构成的环  
    {  
        for(i=0; i<n-1; ++i)  
            printf("%d ", res[i]);  
        printf("%d\n", res[i]);  
    }  
    else  
    {  
        for(i=2; i<=n; i++)// 尝试每个i, 1始终在排头,因此从2开始计算  
        {  
            if(!vis[i] && isPrime[res[cur-1] + i])// i未用过且和前一个数和为素数  
            {  
                res[cur] = i;  
                vis[i] = 1; // 设置标志  
                dfs(cur+1, n);  
                vis[i] = 0; // 回溯, 清除标识  
            }  
        }  
    }  
}  
  
  
int main()  
{  
    int n;  
    //freopen("in.txt", "r", stdin);  
    prime();  
    cnt = 0;  
    while(scanf("%d", &n) != EOF)  
    {  
        ++cnt;  
        printf("Case %d:\n", cnt);  
        memset(vis, 0, sizeof(vis));  
        res[0] = 1;  
        dfs(1, n);  
        printf("\n");  
    }  
    return 0;  
}

总结归纳：
广度优先搜索一般用于求解最优解，
深度优先搜索一般用于求解解存不存在的问题

方寸天地宽
关注
DFS/BFS
qq_40123329的博客
01-30 1103
一 DFS深度优先遍历 有n件物品，每件物品重量为w[i]，价值位c[i]。现在需要选出若干件物品放入一个容量为V的背包中，使得在选入背包中的物品容量和不超过容量V的前提下，让背包中物品的价格之和最大，求最大价值。 由于对每件物品都有选与不选两种选择，这就是岔道口。一旦选择的物品重量之和超过V，就会到达死胡同，需要返回就近的岔道口。 显然每次都要对物品进行选择，因此DFS函数的参数必须记录...
DFS和BFS
Eyumbo的博客
11-19 1197
DFS和BFS初学习
DFS(深度优先搜索)与BFS(广度优先搜索)
Joywy的专栏
07-28 1447
写在最前的三点： 1、所谓图的遍历就是按照某种次序访问图的每一顶点一次仅且一次。 2、实现bfs和dfs都需要解决的一个问题就是如何存储图。一般有两种方法：邻接矩阵和邻接表。这里为简单起见，均采用邻接矩阵存储，说白了 也就是二维数组。 3、本文章的小测试部分的测试实例是下图： 一、深度优先搜索遍历 1、从顶点v出发深度遍历图G的算法 ① 访
dfs和bfs
weixin_30849591的博客
07-31 95
1.dfs(深度优先搜索)是两个搜索中先理解并使用的，其实就是暴力把所有的路径都搜索出来，它运用了回溯，保存这次的位置，深入搜索，都搜索完了便回溯回来，搜下一个位置，直到把所有最深位置都搜一遍，要注意的一点是，搜索的时候有记录走过的位置，标记完后可能要改回来； 回溯法是一种搜索法，按条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择达不到目标，就退回一步重新选择，这种走不通就退回再走的技术...
池塘计数(Flood Fill)
qq_43738331的博客
11-04 741
农夫约翰有一片 N∗MN∗M 的矩形土地。 最近，由于降雨的原因，部分土地被水淹没了。 现在用一个字符矩阵来表示他的土地。 每个单元格内，如果包含雨水，则用”W”表示，如果不含雨水，则用”.”表示。 现在，约翰想知道他的土地中形成了多少片池塘。 每组相连的积水单元格集合可以看作是一片池塘。 每个单元格视为与其上、下、左、右、左上、右上、左下、右下八个邻近单元格相连。 请你输出共有多少片池塘，即矩阵中共有多少片相连的”W”块。 输入格式 第一行包含两个整数 NN 和 MM。 接下来 NN 行，每行包含 MM
DFS&BFS&UCS&Astar.py
06-05
python实现八数码问题，代码可读性较好
数独DFS&BFS.cpp
08-13
在校初学者
第二讲：复习专题之链表,指针,dfs&bfs.pptx
10-05
在C++编程语言中，链表、指针、深度优先搜索(DFS)和广度优先搜索(BFS)是重要的概念，这些概念在处理数据结构和算法时尤其关键。本讲将详细阐述这些主题。 首先，我们来看结构体，它是C++中定义自定义数据类型的一种...
DFS&&BFS&&图.pptx
最新发布
07-26
技术文档分享，免费获取请私信博主。
CSP刷题总结/DFS&BFS
qq_40901482的博客
08-04 347
备考北航机试的时候刷过一些csp和机试题，写了一些总结
DFS与BFS
qq_37377611的博客
05-14 315
一、图的深度优先介绍 1.图遍历介绍 2.深度优先遍历基本思想 3.深度优先遍历算法步骤 二、图的广度优先遍历 2.1广度优先遍历基本思想 2.2广度优先遍历算法步骤
dfs/bfs讲解及应用
李典金
04-25 849
dfs/bfs讲解及应用
第十三章 DFS与BFS（保姆级教学！！超级详细的图示！！）
Turing_Sheep的博客
12-02 5万+
用画图和超详细地注释帮助大家秒懂DFS和BFS!!!!保姆级教学！！！解决你的痛点！！！
DFS与BFS算法
qq_41816189的博客
02-06 2万+
深度优先遍历简称DFS（Depth First Search），广度优先遍历简称BFS（Breadth First Search），它们是遍历图当中所有顶点的两种方式。下面分别介绍两种基本的搜索算法。
dfs与bfs
niepandou的博客
02-06 857
从使用空间看，dfs只需记录这条路径的所有点，空间复杂度为O（h），bfs记录每层的节点，空间复杂度为O（z ^ h），该特点使bfs有了一个最短路的概念。按照字典序输出自然数 1 到 n 所有不重复的排列，即 n 的全排列，要求所产生的任一数字序列中不允许出现重复的数字。每个解决方案占 n 行，每行输出一个长度为 n 的字符串，用来表示完整的棋盘状态。从使用的数据结构来看，dfs使用的是栈，bfs使用的是队列。由 1 - n组成的所有不重复的数字序列，每行一个序列。每个方案输出完成后，输出一个空行。
一文带你了解dfs和bfs算法
Twinkle_sone的博客
01-21 1万+
一文带你了解dfs和bfs算法 如上图，dfs和bfs算法通常会用来解决迷宫问题，两种算法都可以找到一条通往重点的路，但又有不一样的地方。 体验地址：http://120.79.163.94/demo/寻路算法.html 可以自己定义迷宫是否可走，及起始点和终点。 深度优先算法（dfs） 简介 dfs算法又称深度优先搜索，是计算机术语。 1、dfs是一种在开发爬虫早期使用较多的方法，是搜索算法的一种。 2、dfs的目的是要达到被搜索结构的叶结点，即那些不包含任何超链的HTML文件。 3、dfs根据已有的邻
如何通透理解：BFS和DFS优先搜索算法(23年修订版)
热门推荐
结构之法 算法之道
01-01 13万+
4、教你通透彻底理解：BFS和DFS优先搜索算法作者：July二零一一年一月一日---------------------------------本人参考：算法导论 本人声明：个人原创，转载请注明出处。ok，开始。翻遍网上，关于此类BFS和DFS算法的文章，很多。但，都说不出个所以然来。读完此文，我想，你对图的广度优先搜索和深度优先搜索定会有个通通透透，彻彻底底的认识。
DFS和BFS简述
蓝的博客
02-01 3382
DFS与BFS
DFS(深度优先遍历) & BFS:(广度优先遍历)
Kprogram的博客
07-20 5436
DFS (Deep First Search) 概念： 顾名思义，这种遍历方法是以深度为优先进行对图的搜索或者遍历，至于什么是以深度为优先条件，先看下面DFS的基本步骤： （ 这是一个递归思想的DFS） DFS：从当前节点开始，先标记当前节点，再寻找与当前节点相邻，且未标记过的节点： （1）: 当前节点不存在下一个节点，则返回前一个节点进行DF...
树的遍历：DFS与BFS解析
"预备知识——树的遍历-ACM_DFS+BFS" 树的遍历是计算机科学中处理树形结构数据时常用的一种技术，主要用于访问或操作树中的所有节点。在算法竞赛（ACM）和搜索策略（DFS、BFS）中，理解并掌握树的遍历技巧至关重要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值