7.23 深搜广搜

深搜（DFS)  关键词：回溯

栈实现，（递归本质和栈一样）一直走到底再回溯，时间复杂度高，空间低

#include<iostream>
#include<cstring>
using namespace std;
int R,C;
char maps[40][40];
int dp[40][40];
int dir[2][4]={{1,0,0,-1},{0,1,-1,0}};
int ans=1<<30;
void DFS(int x,int y,int step){
      if(x>=R || y>=C || x<0 ||y<0) return ;
      if(x==R-1&&y==C-1) {
        if(step<ans) ans=step;
        return ;
      }
      if(maps[x][y]==‘#‘) return;
      for(int i=0;i<4;i++){
            if(x+dir[0][i] >=R || y+dir[1][i] >=C || x+dir[0][i] <0 || y+dir[1][i] < 0 ) continue;
            if(maps[x+dir[0][i]][y+dir[1][i]]==‘.‘ && !dp[x+dir[0][i]][y+dir[1][i]]){
                 dp[x+dir[0][i]][y+dir[1][i]]=1;
                 DFS(x+dir[0][i],y+dir[1][i],step+1);//也是一直走一直走，直到回溯的时候才置0；
                 dp[x+dir[0][i]][y+dir[1][i]]=0;
            }
      }
}
int main(){
    cin>>R>>C;
    char c;
    for(int i=0;i<R;i++)
    for(int j=0;j<C;j++){
        cin>>c;
        maps[i][j]=c;
        dp[i][j]=0;
    }
    dp[0][0]=1;
    DFS(0,0,1);
    cout<<ans<<endl;
 return 0;
 }

广搜（BFS) 关键词：最优解  结构体

第一次找到的就是最优解（最少步数，最少转弯次数），层次结构，一层一层地搜索，无回溯过程，队列实现，结构体记录状态，入队。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
int R,C;
char maps[40][40];
int dp[40][40];
int dir[2][4]={{1,0,0,-1},{0,1,-1,0}};
int ans=1<<30;
struct node{
    int x;
    int y;
    int step;
    node(int xx,int yy,int tt):x(xx),y(yy),step(tt){}
};
int  bfs()
{
     queue<node> que;
     que.push(node(0,0,1));
     while(!que.empty()){
        node temp = que.front();
        que.pop();
        for(int i=0;i<4;i++){     //上下左右四方向
            int tx=temp.x+dir[0][i];
            int ty=temp.y+dir[1][i];
            int tt=temp.step;
            if(dp[tx][ty]) continue;
            if(tx<0 || tx>=R  || ty<0  || ty>=C ) continue;
            if(maps[tx][ty]==‘#‘) continue;
            if(tx==R-1&&ty==C-1) return tt+1;//直接return，因为最先找到的一定是最优解
            dp[tx][ty]=1;
            que.push(node(tx,ty,tt+1));
        }
    }
}
int main(){
    cin>>R>>C;
    for(int i=0;i<R;i++)
    for(int j=0;j<C;j++){
        cin>>maps[i][j];
        dp[i][j]=0;
    }
    int ans=bfs();
    cout<<ans<<endl;
    return 0;

A题：

AveryBoy最近迷上了连连看游戏，于是他自己写了一个程序来玩，不过由于他学艺不精导致他写的连连看游戏连线不能从外面绕过。

游戏规则：在一个棋盘中，放了很多的棋子。如果某两个相同的棋子，可以通过一条线连起来（这条线不能经过其它棋子），而且线的转折次数不超过两次，那么这两个棋子就可以在棋盘上消去。玩家鼠标先后点击两块棋子，试图将他们消去，然后游戏的后台判断这两个方格能不能消去。现在你的任务就是写这个后台程序。

Input

输入数据有多组。每组数据的第一行有两个正整数n,m(0<n<=1000,0<m<1000)，分别表示棋盘的行数与列数。

在接下来的n行中，每行有m个非负整数描述棋盘的方格分布。0表示这个位置没有棋子，正整数表示棋子的类型。接下来的一行是一个正整数q(0<q<50)，表示下面有q次询问。在接下来的q行里，每行有四个正整数x1,y1,x2,y2,表示询问第x1行y1列的棋子与第x2行y2列的棋子能不能消去。n=0,m=0时，输入结束。

Output

每一组输入数据对应一行输出。如果能消去则输出"YES",不能则输出"NO"。

Sample Input

3 4
1 2 3 4
0 0 0 0
4 3 2 1
4
1 1 3 4
1 1 2 4
1 1 3 3
2 1 2 4
3 4
0 1 4 3
0 2 4 1
0 0 0 0
2
1 1 2 4
1 3 2 3
0 0

Sample Output

YES
NO
NO
NO
NO
YES

这题就是迷宫转弯问题，转弯次数小于等于2即可

#include <bits/stdc++.h>
using namespace std;
int n,m;
int x2,y2;
int maze[1010][1010];
int used[1010][1010];
int nx[4]={1,0,-1,0},ny[4]={0,1,0,-1};
struct node
{
    int x,y;
};
bool canmove(int x,int y)
{
    if(x>=0&&x<n&&y>=0&&y<m&&maze[x][y]==0)return true;
    else if(x>=0&&x<n&&y>=0&&y<m&&maze[x][y]==maze[x2][y2])return true;
    else return false;
}
void bfs(int x,int y)
{
    queue<node> que;
    node now,next;
    now.x=x;
    now.y=y;
    que.push(now);
    bool flag=false;
    while(!que.empty())
    {
        now=que.front();
        que.pop();
        if(now.x==x2&&now.y==y2)
        {
            if(used[x2][y2]<=3)
            {
                flag=true;
                printf("YES\n");
            }
            else break;
        }
        else
        {
            for(int i=0;i<4;i++)
            {
                next.x=now.x+nx[i];
                next.y=now.y+ny[i];
                while(canmove(next.x,next.y))
                {
                    if(used[next.x][next.y]==0)
                    {
                        used[next.x][next.y]=used[now.x][now.y]+1;
                        que.push(next);
                    }
                    next.x+=nx[i];
                    next.y+=ny[i];
                }
            }
        }
    }
    if(flag==false)printf("NO\n");
}
int main()
{
    while(1)
    {
        scanf("%d%d",&n,&m);
        if(n==0&&m==0)break;
        int i,j;
        for(i=0;i<n;i++)
        {
            for(j=0;j<m;j++)scanf("%d",&maze[i][j]);
        }
        int q;
        scanf("%d",&q);
        for(i=0;i<q;i++)
        {
            int x1,y1;
            scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
            x1--,x2--,y1--,y2--;
            if(maze[x1][y1]!=maze[x2][y2])printf("NO\n");
            else if(maze[x1][y1]==0||maze[x2][y2]==0)printf("NO\n");
            else
            {
                bfs(x1,y1);
                memset(used,0,sizeof used);
            }
        }
    }
    return 0;
}

B题：

经典的迷宫转弯问题

AveryBoy被困在一个n行m列的迷宫中了，问他能不能从起点到终点。迷宫中字符‘.‘表示该位置为空地，字符‘*‘表示该位置为障碍，他必须绕行，不过如果他转太多弯就会晕倒。假定给定的两个位置都是空地，初始时，AveryBoy所面向的方向未定，她可以选择4个方向的任何一个出发，而不算成一次转弯。

Input

第1行为一个整数t (1 ≤ t ≤ 100),表示测试数据的个数，接下来为t组测试数据，每组测试数据中，

第1行为两个整数n, m (1 ≤ m, n ≤ 100),分别表示迷宫的行数和列数，接下来n行，每行包括m个字符。

每组测试数据的最后一行为5个整数k, x1, y1, x2, y2 (1 ≤ k ≤ 10, 1 ≤ x1, x2 ≤ n, 1 ≤ y1, y2 ≤ m),其中k表示AveryBoy最多能转的弯数，(x1, y1), (x2, y2)表示起点和终点。

Output

每组测试数据对应为一行，若AveryBoy能从起点到终点，输出“yes”，否则输出“no”。

Sample Input

2
5 5
...**
*.**.
.....
.....
*....
1 1 1 3 1
5 5
...**
*.**.
.....
.....
*....
2 1 1 3 1

Sample Output

no
yes

很经典的转弯问题因为要看能不能过迷宫，利用广搜可以求出最少的转弯次数，如果最少转弯次数<=k,那么就可以通过迷宫特别的是，因为起始方向不确定，所以最开始的转弯不计做一次转弯开一个used[][]数组，记录当前点的转弯次数先将used[][]全置为-1，（其实全置0也一样，最后比较的时候减去1就行)定义now,next节点，对于每一个now节点，遍历它的四个方向关键：找到一个方向，就一直把该方向走完，把这个方向上的所有未被标记过的节点的usd值全部标记，等于上一次转弯节点（now)的used值+1；这里的判重即是判断used[x][y]是否等于-1，若已经标记过，那么我们跳过它，因为有的节点是交叉点


 

思路：对队列里面的坐标（x，y）做选择时，每次选择一个方向（共四个方向）走到不能走为止，将沿途经过的所有used值 = -1的点入队并更新used值（对used不为-1的点不作处理）。队列为空还无法到终点，输出no。若能遍历到终点，判断used值是否大于要求的k，若大于输出no，否则输出yes。

#include <bits/stdc++.h>
using namespace std;
int used[110][110];
int n,m;
int k,x2,y2;
char maze[110][110];
int nx[4]={1,0,-1,0},ny[4]={0,1,0,-1};
struct node
{
    int x,y;
};
bool canmove(int x,int y)
{
    if(x>=0&&x<n&&y>=0&&y<m&&maze[x][y]==‘.‘)return true;
    else return false;
}
void bfs(int x,int y)
{
    queue<node> que;
    node now,next;
    now.x=x;
    now.y=y;
    que.push(now);
    bool flag=false;
    while(!que.empty())
    {
        now=que.front();
        que.pop();
        if(now.x==x2&&now.y==y2)
        {
            if(used[x2][y2]<=k)
            {
                flag=true;
                printf("yes\n");
            }
            else break;
        }
        else
        {
            for(int i=0;i<4;i++)
            {
                next.x=now.x+nx[i];
                next.y=now.y+ny[i];
                while(canmove(next.x,next.y))
                {
                    if(used[next.x][next.y]==-1)
                    {
                        used[next.x][next.y]=used[now.x][now.y]+1;
                        que.push(next);
                    }
                    next.x+=nx[i];
                    next.y+=ny[i];
                }
            }
        }
    }
    if(flag==false)printf("no\n");
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int i,j;
        scanf("%d%d",&n,&m);
        for(i=0;i<n;i++)
        {
            scanf("%s",maze[i]);
        }
        int x1,y1;
        scanf("%d%d%d%d%d",&k,&x1,&y1,&x2,&y2);
        x1--,y1--,x2--,y2--;
         for(i=0;i<n;i++)
        {
            for(j=0;j<m;j++)used[i][j]=-1;
        }
        bfs(x1,y1);
    }
    return 0;
}

C题：

这次AveryBoy被困在一个三维迷宫中，他必须想办法在T分钟内离开迷宫（包括T）。迷宫是一个A*B*C的立方体，起点在（0，0，0）位置，终点在（A-1，B-1，C-1）位置。如果他能离开迷宫，输出离开迷宫所需最短时间，否则输出-1。

三维迷宫问题，仍然是找最优解，求最小步数（时间）在二维基础上修改结构体内x,y为x,y,z，修改方向为x,y,z方向上的六个方向即可，稍加变通，不要被吓到。

#include <bits/stdc++.h>
using namespace std;
int maze[55][55][55];
int nx[6]={1,-1,0,0,0,0};
int ny[6]={0,0,1,-1,0,0};
int nz[6]={0,0,0,0,1,-1};
int dp[55][55][55];
int X,Y,Z;
struct node
{
    int x,y,z,step;
    node(int xx,int yy,int zz,int ss):x(xx),y(yy),z(zz),step(ss){}
};
int  bfs()
{
     queue<node> que;
     que.push(node(0,0,0,0));
     bool flag=false;
     while(!que.empty())
    {
        node temp = que.front();
        que.pop();
        for(int i=0;i<6;i++)
            {     //上下左右四方向
            int tx=temp.x+nx[i];
            int ty=temp.y+ny[i];
            int tz=temp.z+nz[i];
            int tt=temp.step;
            if(dp[tx][ty][tz]) continue;
            if(tx<0 || tx>=X  || ty<0  || ty>=Y||tz<0||tz>=Z ) continue;
            if(maze[tx][ty][tz]==1) continue;
            if(tx==X-1&&ty==Y-1&&tz==Z-1)
            {
                flag=true;
                return tt+1;//直接return，因为最先找到的一定是最优解
            }
            dp[tx][ty][tz]=1;
            que.push(node(tx,ty,tz,tt+1));
        }
    }
    if(flag==false)return -1;
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int tt;
        scanf("%d%d%d%d",&X,&Y,&Z,&tt);
        int i,j,k;
        for(i=0;i<X;i++)
        {
            for(j=0;j<Y;j++)
            {
                for(k=0;k<Z;k++)
                {
                    scanf("%d",&maze[i][j][k]);
                }
            }
        }
        memset(dp,0,sizeof dp);
        int ans=bfs();
        if(ans<=tt&&ans!=-1)printf("%d\n",ans);
        else printf("-1\n");
    }
    return 0;
}

D题：

如下图的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。

我们把第一个图的局面记为：12345678.

把第二个图的局面记为：123.46758

显然是按从上到下，从左到右的顺序记录数字，空格记为句点。

本题目的任务是已知九宫的初态和终态，求最少经过多少步的移动可以到达。如果无论多少步都无法到达，则输出-1。

经典的八数码问题，依然找最优解，用字符串记状态，结构体数组内放入现在数码块的状态char sz[3][3]，开一个map<string,int>记录该状态是否已出现过，用x,y记录0的位置

剪枝，奇排列永远不能变成偶排列

#include<bits/stdc++.h>
using namespace std;
char s1[10],f1[10];
bool nixu()
{
    int ans1=0;
    int ans2=0;
    int i,j;
    string ss1="",ff1="";
    for(i=0;i<9;i++)
    {
        if(s1[i]!=‘.‘)ss1+=s1[i];
        if(f1[i]!=‘.‘)ff1+=f1[i];
    }
    //cout<<ss1<<endl;
    //cout<<ff1<<endl;
    for(i=1;i<8;i++)
    {
        for(j=0;j<8-i;j++)
        {
            if(ss1[j]>ss1[j+1])
            {
                char t=ss1[j];
                ss1[j]=ss1[j+1];
                ss1[j+1]=t;
                ans1++;
            }
        }
    }
     for(i=1;i<8;i++)
    {
        for(j=0;j<8-i;j++)
        {
            if(ff1[j]>ff1[j+1])
            {
                char t=ff1[j];
                ff1[j]=ff1[j+1];
                ff1[j+1]=t;
                ans2++;
            }
        }
    }
    //cout<<ans1<<‘ ‘<<ans2;
    if(ans1%2!=ans2%2)return false;
    else return true;
}
struct node
{
    int x,y,step;  //x,y记下0（.）的位置
    char sz[3][3];
};
char start[10],finally[10];
string temp;
map<string,bool> mp;//代表状态有无被标记  字符串代表状态
int inf=999999999;
int nx[4]={1,0,0,-1},ny[4]={0,1,-1,0};
int bfs()
{
    int ans=inf;
    node now,next;
    int d=0,i,j;
    for(i=0;i<3;i++)
    {
        for(j=0;j<3;j++)
        {
            now.sz[i][j]=start[d++];
            if(now.sz[i][j]==‘.‘)
            {
                now.x=i;
                now.y=j;
            }
        }
    }
    now.step=0;
    queue<node> que;
    que.push(now);
    while(!que.empty())
    {
        now=que.front();
        que.pop();
        for(i=0;i<4;i++)
        {
            next=now;    //让这两个状态下的字符数组都相同
            next.x=now.x+nx[i];
            next.y=now.y+ny[i];
            if(next.x<0||next.x>2||next.y<0||next.y>2)continue;
            next.step=now.step+1;
            next.sz[now.x][now.y]=next.sz[next.x][next.y];//now.x,now.y代表的就是先前状态下的0的位置
            next.sz[next.x][next.y]=‘.‘;//与0交换
            temp="";
            for(j=0;j<3;j++)
            {
                for(int k=0;k<3;k++)
                    temp+=next.sz[j][k];
            }
            if(temp==finally)
            {
                ans=min(ans,next.step);
            }
            if(!mp[temp])
            {
                mp[temp]=true;
                que.push(next);
            }
        }
    }
    return ans;
}
int main()
{
    int t;
    cin>>t;
    while(t--)
       {
           scanf("%s%s",start,finally);
           strcpy(s1,start);
        strcpy(f1,finally);
        if(!nixu())printf("-1\n");
        else
        {
            int ans=bfs();
            //cout<<ans<<endl;
            if(ans==inf)printf("-1\n");
            else printf("%d\n",ans);
        }
       }
    return 0;
}




原文地址：https://www.cnblogs.com/raincle/p/9368312.html
				


				
时间： 2024-11-05 13:47:23 

		


		


	

	
	

		


		
7.23  深搜广搜的相关文章


						

		

			

                HDU 4771 Stealing Harry Potter&#39;s Precious （深搜+广搜）
			

		

		

									

				题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=4771 题面: 欢迎参加--BestCoder周年纪念赛(高质量题目+多重奖励) Stealing Harry Potter's Precious Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 2207    Accepted Submis			

		

	

				

		

			

                leetcode 深搜广搜
			

		

		

									

				遍历整个grid数组,当发现有1的时候,就把和这个1连成片的1都置为0,并增加一个计数.最后返回这个计数. 广搜,但这个代码通不过测试,栈溢出. class Solution { public: void bfs(vector<vector<char>>& grid,int i,int j){ if(i<0||j<0||i>=grid.size()||j>=grid[0].size()) return; if(grid[i][j]=='0') ret			

		

	

						

		

			

                迷宫问题（深搜 广搜）
			

		

		

									

				题目描述: 给出一个m*n的迷宫图和一个入口,一个出口. 编一个程序,打印一条从迷宫入口到出口的路径. -1表示走不通,0表示能走,只能上下左右走: 无路可走输出"no way": 样例输入: 8 5-1 -1 -1 -1 -1 0 0 0 0 -1-1 -1 -1 0 -1-1 0 0 0 -1-1 0 0 1 -1-1 0 0 0 -1-1 -1 -1 0 -1-1 0 0 0 -12 18 4 8 5-1 -1 -1 -1 -10 0 0 0 -1-1 -1 -1 0 -1-1			

		

	

				

		

			

                DFS-BFS（深搜广搜）原理及C++代码实现
			

		

		

									

				深搜和广搜是图很多算法的基础,很多图的算法都是从这两个算法中启发而来. 深搜简单地说就是直接一搜到底,然后再回溯,再一搜到底,一直如此循环到没有新的结点. 广搜简单地说就是一层一层的搜,像水的波纹一样往外面扩散,扩散到最外层搜索也就完成了. prim最小生成树.Dijkstra单源最短路径算法都使用了类似广度优先搜索的思想. 拓扑排序就可以用深搜来实现,分解强连通分量也可以用深搜来实现(转置图加两次深搜) 我们实现广搜时需要用队列来辅助我们进行.实现深搜时使用栈来辅助我们进行,所以显而易见的用递			

		

	

				

		

			

                图的创建,深搜,广搜（基于临接表实现）
			

		

		

									

				#include <stdio.h> #include <stdlib.h> #include <iostream> #include <queue> using namespace std; #define MaxVertexNum 100 //最大顶点数 typedef enum{DG,UDG,DN,UDN} GraphKind; //图的种类 typedef int InfoType; typedef char VertexType; typedef			

		

	

				

		

			

                965. 单值二叉树(深搜/广搜)
			

		

		

									

				1 /** 2 * Definition for a binary tree node. 3 * public class TreeNode { 4 * int val; 5 * TreeNode left; 6 * TreeNode right; 7 * TreeNode(int x) { val = x; } 8 * } 9 */ 10 class Solution { 11 private int val; 12 private boolean flag=true; 13 public b			

		

	

				

		

			

                深搜,广搜
			

		

		

									

				//实验要求: //用邻接表存储一个无向图, //深度优先,广度优先遍历 //拓扑排序 #include<stdio.h> #include<stdlib.h> #include<string.h> typedef int status ; struct ljno //邻接表数据类型 { int x; //存储数据 ljno* next; }ss; struct ALGraph { ljno *data ; int vexnum,exnum;//顶点个数和边的个数 };			

		

	

				

		

			

                迷宫广搜
			

		

		

									

				上学期学了C,这学期学C++.感觉最难的还是算法,上周作业的一道广搜题是我第一次接触广搜,由于第一学期刚学编程就接触的太多的算法难题,不禁对代码产生畏惧,不过还好没有放弃,虽然算法很难,但我慢慢找到了一点学数学时的乐趣.先介绍一下这道未来的我看过来会觉得很简单一道题吧 You are provided a maze(迷宫), and you need to program to find the least steps to walk from the start to the end.And			

		

	

				

		

			

                最短路问题------分别用深搜和广搜去解题
			

		

		

									

				最少步数 时间限制:3000 ms | 内存限制:65535 KB 难度:4 描述 这有一个迷宫,有0~8行和0~8列: 1,1,1,1,1,1,1,1,1 1,0,0,1,0,0,1,0,1 1,0,0,1,1,0,0,0,1 1,0,1,0,1,1,0,1,1 1,0,0,0,0,1,0,0,1 1,1,0,1,0,1,0,0,1 1,1,0,1,0,1,0,0,1 1,1,0,1,0,0,0,0,1 1,1,1,1,1,1,1,1,1 0表示道路,1表示墙. 现在输入一个道路的坐标作为起点