DFS与BFS小结

DFS！！！
1、2020蓝桥杯决赛A组E题《玩具蛇》
难度：**
题意 ：在4*4矩阵中放入1-16号数字，使得连续的数字相邻，则放法有多少种（设每个格子均不同）

思路：1个1个放，上下左右探索。巩固深搜语法——visit置1，搜索下一层，visit置0。

int visit[4][4],cnt=0;  //设置是否经过，计数
int x[4]={-1,0,1,0},y[4]={0,-1,0,1}; //探索方向
void init(){  //重新开始的初始化函数
    for (int i=0;i<4;i++){
        for (int j=0;j<4;j++) visit[i][j]=0;
    }
}
void dfs(int i,int j,int step){
    if (step==16){ //数字16被放置成功
        cnt+=1;
        return;
    }
    for (int k=0;k<4;k++){
        int nx=i+x[k],ny=j+y[k];
        if (nx<0 || ny<0 || nx>3 || ny>3 || visit[nx][ny]==1) continue; //违规数据和已占格子
        visit[nx][ny]=1;
        dfs(nx,ny,step+1); //搜索下一层
        visit[nx][ny]=0;
    }
}
int main(){
    for (int i=0;i<4;i++){
        for (int j=0;j<4;j++){
            init();
            visit[i][j]=1;
            dfs(i,j,1); //开始本次搜索
            visit[i][j]=0;
        }
    }
    cout<<cnt<<endl;
    return 0;
}

2、EOJ 1084华师大卫星照片
题意：输入只有’*‘和’.‘的矩阵，找成片’*'的最大面积

难度：**
输入样例:
10 5
……**
.…***
.……
….
…*.
输出：
16
思路：从矩阵左上角到右下角寻找，找到则置visit为1，并且不再置为0。比较得出最大的’*‘团个数。

int visit[80][1000]; //是否经过
int w,h,cnt,maxi=0; //宽度，高度，计数
char photo[80][1000];
int x[4]={-1,0,1,0},y[4]={0,-1,0,1};
void init(){ //初始化经过列表
    for (int i=0;i<h;i++){
        for (int j=0;j<w;j++) visit[i][j]=0;
    }
}
void dfs(int i,int j){ //开始搜索
    for (int k=0;k<4;k++){
        int nx=i+x[k],ny=j+y[k]; //规定方向
        if (nx<0 || ny<0 || nx>=h || ny>=w || visit[nx][ny]==1 || photo[nx][ny]=='.') continue; 
        //违规或已占或非建筑
        else{
            visit[nx][ny]=1; //标记已经过
            cnt+=1;
            dfs(nx,ny); //继续搜索
        }
    }
}
int main(){
    init();
    string str;
    //输入处理
    cin>>w>>h;
    for (int i=0;i<h;i++){
        cin>>str;
        for (int j=0;j<w;j++) photo[i][j]=str[j];
    }
    //开始搜索
    for (int i=0;i<h;i++){
        for (int j=0;j<w;j++){
            cnt=1;
            if (visit[i][j]==0 && photo[i][j]=='*'){ //未经过且是建筑
                visit[i][j]=1;
                dfs(i,j);
                if (cnt>maxi) maxi=cnt; //找到最大点数
            }
        }
    }
    cout<<maxi<<endl;
    return 0;
}

还是递归写法，但是明显时间消耗减少（只传递数字的原因）：

//上下左右：递归走迷宫
string graph[1001];
int n,m,i,j,t,maxi=0;
int num(int a,int b){
    if (a>=m || a<0 || b>=n || b<0) return 0;
    if (graph[a][b]=='.') return 0;
    else{
        graph[a][b]='.';
        return 1+num(a+1,b)+num(a-1,b)+num(a,b+1)+num(a,b-1);
    }
}
int main(){
    cin>>n>>m;
    for (i=0;i<m;i++) cin>>graph[i];
    for (i=0;i<m;i++){
        for (j=0;j<n;j++){
            if (graph[i][j]=='*'){
                t=num(i,j);
                if (maxi<t) maxi=t;
            }
        }
    }
    cout<<maxi;
    return 0;
}

3、经典的迷宫问题——EOJ 1025
题目：n*n的矩阵由0和1组成，0表示可走，1表示障碍。给定入口和出口，求是否有路径可以走出迷宫。
难度： ***
经过：继续使用上述DFS模型，结斜体样式果超时（再次印证了递归只能解决小规模问题——指数级时间复杂度），所以换种写法。
超时写法（仅用于超小规模迷宫）：

int miro[100][100],visit[100][100]; //迷宫和访问矩阵
int n,cnt=0; //迷宫规格及路径计数
int startx,starty,endx,endy; //起点和终点
/*制定行走规则
0 1 2
3   4
5 6 7
*/
int x[8]={-1,0,1,-1,1,-1,0,1},y[8]={-1,-1,-1,0,0,1,1,1};
void init(){ //访问矩阵初始化
    for (int i=0;i<n;i++){
        for (int j=0;j<n;j++) visit[i][j]=0;
    }
}
void dfs(int i,int j){
    if (i==endx && j==endy){
        cnt+=1; //有几条路径
        return;
    }
    for (int k=0;k<8;k++){
        int nx=i+x[k],ny=j+y[k];//方向选择
        if (nx<0 || ny<0 || nx>=n || ny>=n || visit[nx][ny]==1 || miro[nx][ny]==1) continue;
        //违规或已占或已经过
        else{ //可走的路
            visit[nx][ny]=1;
            dfs(nx,ny);
            visit[nx][ny]=0;
        }
    }
    return;
}
int main(){
    //输入处理
    string in;
    cin>>n>>startx>>starty>>endx>>endy;
    for (int i=0;i<n;i++){
        cin>>in;
        for (int j=0;j<n;j++) miro[i][j]=in[j]-'0';
    }
    //初始化并开始搜索
    init();
    visit[startx][starty]=1;
    dfs(startx,starty);
    if (cnt) cout<<"yes"<<endl;
    else cout<<"no"<<endl;
    return 0;
}

众所周知，DFS递归=循环+栈，BFS递归=循环+队列，使用栈代替递归就不超时了，AC码如下。

#include <stack>
/*行走方向的设立*/
struct store{int x=0,y=0;};
store rule[8];
void init(){
    /*制定规则
    0 1 2
    3   4
    5 6 7
    */
    rule[0].x=-1; rule[0].y=-1;
                  rule[1].y=-1;
    rule[2].x=1;  rule[2].y=-1;
    rule[3].x=-1;
    rule[4].x=1;
    rule[5].x=-1; rule[5].y=1;
                  rule[6].y=1;
    rule[7].x=1;  rule[7].y=1;
}
/*记录路径单元的结构体*/
struct step{int x,y,how;};
int main(){
     //初始化方向、迷宫出入口
    init();
    int n,inx,iny,outx,outy; cin>>n;
    cin>>inx>>iny>>outx>>outy; 
    //初始化迷宫
    int maze[n][n],judge[n][n]; // 迷宫&判断走过没
    string in;
    for (int i=0;i<n;i++){
        cin>>in;
        for (int j=0;j<n;j++) maze[i][j] = in[j]-'0';
    }
    int k=0,flag=1,nowx,nowy,go;  //第一步、是否成功、当前位置与方向
    for (k;k<8&&flag;k++){
        stack<step> line;//从起点重新开始
        line.push({inx,iny,k});
        for (int i=0;i<n;i++){
            for (int j=0;j<n;j++) judge[i][j] = 0;
        }
        judge[inx][iny] = 1; //已走过
        while (line.size()&&flag){
            go = k;  //当前方向
            while (go<8&&flag){
                nowx = line.top().x+rule[go].x;
                nowy = line.top().y+rule[go].y;
                if (nowx<0 || nowx>=n || nowy<0 || nowy>=n) go+=1; //超过可走范围
                else{
                    if (nowx==outx && nowy==outy){  //成功走出
                        flag = 0;
                        break;
                    }
                    if (maze[nowx][nowy]==0 && judge[nowx][nowy]==0){ //没走过
                        line.push({nowx,nowy,go});
                        judge[nowx][nowy] = 1; //走过了
                        go = 0;  //接着走
                    }
                    else go+=1; //换方向试试
                }
            }
            if (go>7) line.pop();  //走不通了换条路
        }
    }
    if (flag==0) cout<<"yes"<<endl;
    else cout<<"no"<<endl;
    return 0;
}

4、链接: 迷宫出路个数及最少步数问题.

BFS！！！
1、19年蓝桥省A的D题【输出最短路径的最小字典序】

01010101001011001001010110010110100100001000101010
00001000100000101010010000100000001001100110100101
01111011010010001000001101001011100011000000010000
01000000001010100011010000101000001010101011001011
00011111000000101000010010100010100000101100000000
11001000110101000010101100011010011010101011110111
00011011010101001001001010000001000101001110000000
10100000101000100110101010111110011000010000111010
00111000001010100001100010000001000101001100001001
11000110100001110010001001010101010101010001101000
00010000100100000101001010101110100010101010000101
11100100101001001000010000010101010100100100010100
00000010000000101011001111010001100000101010100011
10101010011100001000011000010110011110110100001000
10101010100001101010100101000010100000111011101001
10000000101100010000101100101101001011100000000100
10101001000000010100100001000100000100011110101001
00101001010101101001010100011010101101110000110101
11001010000100001100000010100101000001000111000010
00001000110000110101101000000100101001001000011101
10100101000101000000001110110010110101101010100001
00101000010000110101010000100010001001000100010101
10100001000110010001000010101001010101011111010010
00000100101000000110010100101001000001000000000010
11010000001001110111001001000011101001011011101000
00000110100010001000100000001000011101000000110011
10101000101000100010001111100010101001010000001000
10000010100101001010110000000100101010001011101000
00111100001000010000000110111000000001000000001011
10000001100111010111010001000110111010101101111000
思路：用node结构体记录走过路径及步数，寻找最小步数及最小字典序路径
代码：

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

int n=30,m=50,visit[30][50];
struct Node{int x,y,step;string str;};
char maze[30][50];
string in="010101010010110010010101100101101001000010001010100000100010000010101001000010000000100110011010010101111011010010001000001101001011100011000000010000010000000010101000110100001010000010101010110010110001111100000010100001001010001010000010110000000011001000110101000010101100011010011010101011110111000110110101010010010010100000010001010011100000001010000010100010011010101011111001100001000011101000111000001010100001100010000001000101001100001001110001101000011100100010010101010101010100011010000001000010010000010100101010111010001010101000010111100100101001001000010000010101010100100100010100000000100000001010110011110100011000001010101000111010101001110000100001100001011001111011010000100010101010100001101010100101000010100000111011101001100000001011000100001011001011010010111000000001001010100100000001010010000100010000010001111010100100101001010101101001010100011010101101110000110101110010100001000011000000101001010000010001110000100000100011000011010110100000010010100100100001110110100101000101000000001110110010110101101010100001001010000100001101010100001000100010010001000101011010000100011001000100001010100101010101111101001000000100101000000110010100101001000001000000000010110100000010011101110010010000111010010110111010000000011010001000100010000000100001110100000011001110101000101000100010001111100010101001010000001000100000101001010010101100000001001010100010111010000011110000100001000000011011100000000100000000101110000001100111010111010001000110111010101101111000";
//按字典序存储方向
int X[4]={1,0,0,-1},Y[4]={0,-1,1,0};
string dir="DLRU",road;

void init(){
    for(int i=0;i<n;i++){
		for(int j=0;j<m;j++)  visit[i][j]=0;
	}
	visit[0][0]=1;
}
//点的合法性
bool legal(int x,int y){
	if(x<0 || x>=n || y<0 || y>=m)  return false;
	return true;
}
//广度搜索
void bfs(){
    //初始化
	queue<Node> store;
	Node sta={0,0,0,""};
	store.push(sta);
	int mini=100000000;

	init();//初始化经过
	while(!store.empty()){
		Node t=store.front();
		if(t.x==n-1&&t.y==m-1){//到达终点
			if(t.step<mini){
				mini=t.step;
				road=t.str;
			}
			if(t.step==mini && t.str<road) road=t.str; //最小字典序
		}
		else{
			for(int i=0;i<4;i++){
			    int nowx = t.x+X[i] , nowy = t.y+Y[i];
				if(legal(nowx,nowy) && !visit[nowx][nowy] && maze[nowx][nowy]=='0'){
					Node temp={nowx,nowy,t.step+1,t.str+dir[i]};
					store.push(temp);
					visit[nowx][nowy]=1;
				}
			}
		}
		store.pop();//弹出队头元素
	}
	cout<<road;
}
int main(){
    int cnt=0;
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++) maze[i][j]=in[cnt++];
	}
	bfs();
	return 0;
}