dfs和bfs的模板和区别

bfs是按一层一层访问的，所以适合求最短的步数（一般队列+bfs），求解最优解

dfs是按递归实现的，是优先搜索深度，在回溯优先访问的是否有没有访问过的节点，一般是寻找对应的解。

bfs模板

#include<iostream>
#include<cstdio>
#include<queue>
#include<string.h>
using namespace std;


char G[25][25];
int vis[25][25];
int dir[4][2]= {{0,1},{1,0},{0,-1},{-1,0}};
int n,m,sx,sy,fx,fy,tme;
struct node
{
    int x,y,t;
};
int isout(int x,int y){
    if(x<0||x>=n||y<0||y>=m){
        return 1;
    }
    if(vis[x][y]==1){
        return 1;
    }
    if(G[x][y]=='#'){
        return 1;
    }
    return 0;
}

void bfs()
{
    queue<node> q;
    node p,next;
    p.x=sx;  p.y=sy; p.t=0;
    vis[p.x][p.y]=1;
    q.push(p);

    while(!q.empty())
    {
        p=q.front();
        q.pop();

        if(p.x==fx&&p.y==fy)
        {
            tme=p.t;
            return ;
        }

        for(int i=0; i<4; i++)
        {
            next.x=p.x+dir[i][0];
            next.y=p.y+dir[i][1];

            if(isout(next.x,next.y))
                continue;
            if(G[next.x][next.y]=='.')
            {
                next.t=p.t+1;
                vis[next.x][next.y]=1;
                q.push(next);
            }
            else
            {
                next.t=p.t+2;
                vis[next.x][next.y]=1;
                q.push(next);
            }
        }
    }
}
int main()
{
    while(~scanf("%d %d",&n,&m))
    {
        memset(vis,0,sizeof(vis));
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<m; j++)
            {
                cin>>G[i][j];
                if(G[i][j]=='r')
                {
                    G[i][j]='.';
                    sx=i;
                    sy=j;
                }
                if(G[i][j]=='a')
                {
                    G[i][j]='.';
                    fx=i;
                    fy=j;
                }
            }
        }
        bfs();
        cout<<tme<<endl;
    }
    return 0;
}

dfs模板

#include<iostream>
#include<cstdio>
#include<string.h>
using namespace std;

char pic[105][105];
int m,n,idx[105][105];


void dfs(int r,int c,int id)
{
    if(r<0||r>=m||c<0||c>=n) return ;
    if(idx[r][c]>0 || pic[r][c]!='@') return ;
    idx[r][c] = id;
    for(int dr=-1; dr<=1;dr++)
    for(int dc=-1;dc<=1;dc++)
      if(!(dr==0&&dc==0)) dfs(r+dr, c+dc, id);
}

int main()
{
    int cnt;
    while(~scanf("%d%d",&m,&n)&&(m!=0&&n!=0))
    {
        getchar();
        cnt=0;
        memset(idx,0,sizeof(idx));
        for(int i=0;i<m;i++) scanf("%s",pic[i]);
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(idx[i][j] == 0 && pic[i][j]=='@')
                    dfs(i,j,++cnt);
            }
        }
        printf("%d\n",cnt);
    }

}

#include <iostream>
#include <iomanip>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <list>
#include <stack>
#include <deque>
#include <queue>
#include <vector>
#include <algorithm>
#include <functional>
#define PI acos(-1.0)
#define eps 1e-10
#define INF 0x7fffffff
#define debug(x) cout << "--------------> " << x << endl
typedef long long LL;
typedef unsigned long long ULL;
using namespace std;
/*
BFS: 对于解决最短或最少问题特别有效，而且寻找深度小，但缺点是内存耗费量大（需要开大量的数组单元用来存储状态）。

DFS：对于解决遍历和求所有问题有效，对于问题搜索深度小的时候处理速度迅速，然而在深度很大的情况下效率不高

*/

int w, h, l, m;//h行，w列，l时间，m宝石数量
int val[60];//1到m个宝石的价值
char matrix[60][60];
bool used[60][60];//bfs访问标记
bool visited[60];//dfs访问标记
int step[60][60];//走到这步话花费的时间
int ans;//结果
int sum;//所有宝石的价值和
int mov[4][2] = { { -1,0 },{ 1,0 },{ 0,1 },{ 0,-1 } };
int dis[60][60];//记录初始位置、各宝石和出口两两间的距离

				/* 从(x1,y1)到其他点的距离，s范围是0到m+1,0代表起始位置，m+1表示出口，1到m分别表示第i个宝物 */
void BFS(int x1, int y1, int s)
{
	queue<int> q;
	memset(used, 0, sizeof(used));
	memset(step, 0, sizeof(step));

	int u = x1*w + y1;
	q.push(u);
	used[x1][y1] = true;
	step[x1][y1] = 0;
	while (!q.empty())
	{
		u = q.front();
		q.pop();
		int x = u / w;
		int y = u%w;
		for (int i = 0; i < 4; i++)
		{
			int xx = x + mov[i][0];
			int yy = y + mov[i][1];
			if (xx < 0 || xx >= h || yy < 0 || yy >= w) continue;
			if (used[xx][yy] || matrix[xx][yy] == '*') continue;
			used[xx][yy] = true;
			step[xx][yy] = step[x][y] + 1;
			if (matrix[xx][yy] == '@') dis[s][0] = dis[xx][yy];
			else if (matrix[xx][yy] == '<') dis[s][m + 1] = step[xx][yy];
			else if (matrix[xx][yy] >= 'A'&&matrix[xx][yy] <= 'J')
				dis[s][matrix[xx][yy] - 'A' + 1] = step[xx][yy];

			q.push(xx*w + yy);
		}
	}
}

/* s表示当前点，value表示获得的价值，time表示花费的时间 */
void DFS(int s, int value, int time)
{
	if (time > l) return;
	if (ans == sum) return;
	if (s > m)
	{
		if (value > ans)
			ans = value;
		return;
	}
	for (int i = 0; i <= m + 1; i++)
	{
		if (dis[s][i] == 0 || visited[i]) continue;
		visited[i] = true;
		DFS(i, value + val[i], time + dis[s][i]);
		visited[i] = false;
	}
}

int main()
{
	int T;
	scanf("%d", &T);
	for (int iCase = 1; iCase <= T; iCase++)
	{
		memset(dis, 0, sizeof(dis));
		scanf("%d%d%d%d", &w, &h, &l, &m);
		sum = 0;
		ans = -1;

		for (int i = 1; i <= m; i++)
		{
			scanf("%d", &val[i]);
			sum += val[i];
		}

		val[0] = val[m + 1] = 0;//!!!!

		for (int i = 0; i < h; i++)
			scanf("%s", &matrix[i]);

		for (int i = 0; i < h; i++)
		{
			for (int j = 0; j < w; j++)
			{
				if (matrix[i][j] == '@') BFS(i, j, 0);
				else if (matrix[i][j] == '<') BFS(i, j, m + 1);
				else if (matrix[i][j] >= 'A'&&matrix[i][j] <= 'J')
					BFS(i, j, matrix[i][j] - 'A' + 1);
			}
		}
		memset(visited, 0, sizeof(visited));
		visited[0] = true;

		DFS(0, 0, 0);

		printf("Case %d:\n", iCase);
		if (ans >= 0)printf("The best score is %d.\n", ans);
		else printf("Impossible\n");

		if (iCase!=T)
			printf("\n");
	}

	return 0;
}