BFS/DFS常见板子

首先，BFS返回的一定是最短路径；

所以用queue存；

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;

int count1[210][210]//*路径记录器； 
int visited[210][210];//*探索是否访问 
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};//*四方向搜索
//*int nx[] = {1,-1,0,0,0,0};  int ny[] = {0,0,1,-1,0,0};  int nz[] = {0,0,0,0,1,-1}; 六方向*// 
struct node{  //*标记当前坐标 
    int x;
    int y;
};

bool check(int x,int y)  //*约束条件 
{
    /*****/
}
void bfs(int flag,int x,int y)
{
    int f=0,r=0,x1,y1;//*队列 
    node p,temp;
    queue<node>q;
    p.x=x;
    p.y=y;
    q.push(p);
        while(!q.empty())
        {
          p=q.front();
          q.pop();
          for(int i=0;i<4;i++)
          {
              x1=p.x+dir[i][0];
			  y1=p.y+dir[i][1];
              if(check(x1,x2))
              {
                 visited[x1][x2]=0;
                 temp.x=x1;
                 temp.y=x2;
                 q.push(temp);
                 count[x1][y1]=count[p.x][p.y]+1;//*搜索步数为上一步+1. 
              }
          }
        }
}

int main()
{
	memset(count1,0,sizeof(count1));
	memset(vis,0,sizeof(vis));
	/*****/
}

DFS的思想就是搜到底；

DFS:
#include<cstdio>
#include<cstring>
#include<cstdlib>
using namespace std;
const int maxn=100;
bool vst[maxn][maxn]; // 访问标记
int map[maxn][maxn]; // 坐标范围
int dir[4][2]={0,1,0,-1,1,0,-1,0}; // 四个方向

bool CheckEdge(int x,int y) // 边界条件和约束条件的判断
{
	if(!vst[x][y] && ...) // 满足条件
		return 1;
	else // 与约束条件冲突
		return 0;
}

void dfs(int x,int y)
{
	vst[x][y]=1; // 标记该节点被访问过
	if(map[x][y]==G) // 出现目标态G
		{
		...... // 做相应处理
		return;
		}
	for(int i=0;i<4;i++)
	{
		if(CheckEdge(x+dir[i][0],y+dir[i][1])) // 按照规则生成下一个节点
			dfs(x+dir[i][0],y+dir[i][1]);
	}
	return; // 没有下层搜索节点，回溯
}
int main()
{
......
return 0;
}