CSP 201312-5 I’m stuck! 两次BFS

最新推荐文章于 2023-04-19 17:59:42 发布
最新推荐文章于 2023-04-19 17:59:42 发布
阅读量482 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l_x_4/article/details/78289833
版权

试题编号： 201312-5
试题名称： I’m stuck!
时间限制： 1.0s
内存限制： 256.0MB
问题描述：
问题描述
　　给定一个R行C列的地图，地图的每一个方格可能是'#', '+', '-', '|', '.', 'S', 'T'七个字符中的一个，分别表示如下意思：
　　'#': 任何时候玩家都不能移动到此方格；
　　'+': 当玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；
　　'-': 当玩家到达这一方格后，下一步可以向左右两个方向相邻的一个非'#'方格移动一格；
　　'|': 当玩家到达这一方格后，下一步可以向上下两个方向相邻的一个非'#'方格移动一格；
　　'.': 当玩家到达这一方格后，下一步只能向下移动一格。如果下面相邻的方格为'#'，则玩家不能再移动；
　　'S': 玩家的初始位置，地图中只会有一个初始位置。玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；
　　'T': 玩家的目标位置，地图中只会有一个目标位置。玩家到达这一方格后，可以选择完成任务，也可以选择不完成任务继续移动。如果继续移动下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格。
　　此外，玩家不能移动出地图。
　　请找出满足下面两个性质的方格个数：
　　1. 玩家可以从初始位置移动到此方格；
　　2. 玩家不可以从此方格移动到目标位置。
输入格式
　　输入的第一行包括两个整数R 和C，分别表示地图的行和列数。(1 ≤ R, C ≤ 50)。
　　接下来的R行每行都包含C个字符。它们表示地图的格子。地图上恰好有一个'S'和一个'T'。
输出格式
　　如果玩家在初始位置就已经不能到达终点了，就输出“I'm stuck!”（不含双引号）。否则的话，输出满足性质的方格的个数。
样例输入
5 5
--+-+
..|#.
..|##
S-+-T
####.
样例输出
2
样例说明
　　如果把满足性质的方格在地图上用'X'标记出来的话，地图如下所示：
　　--+-+
　　..|#X
　　..|##
　　S-+-T
　　####X

这个题由于数据量特别小所以有些简单，最大50*50的数组，用两次BFS复杂度在n^2的数量级2500*2500<<10^8.



代码写的有些糙，因为刚开始没想到这么简单用的简单的方法，但是可能逻辑上存在一些漏洞，一直是20分，于是才发现只有50行…………


   
   

    
    #include <iostream>
   
   

   
   

    
    #include<algorithm>
   
   

   
   

    
    #include<queue>
   
   

   
   

    
    #include<string.h>
   
   

   
   

    
    bool mazes[100][100];
   
   

   
   

    
    using namespace std;
   
   

   
   

    
    int maze1[100][100];
   
   

   
   

    
    bool mazet[100][100];
   
   

   
   

    
    int M,N;
   
   

   
   

    
        int i,j;
   
   

   
   

    
    int sx,sy,tx,ty;
   
   

   
   

    
    struct zuobiao
    
    {
   
   

   
   

    
    zuobiao zuobiaos[4]{zuobiao(-1,0),zuobiao(1,0),zuobiao(0,-1),zuobiao(0,1)};
   
   

   
   

    
        zuobiao(int x,int y):i(x),j(y){}
   
   

   
   

    
    };
   
   


   
   

    
    bool bfss(int x,int y)
    
    {
   
   

   
   

    
        que.push(zb);
   
   

   
   

    
        zuobiao zb(x,y);
   
   

   
   

    
        queue<zuobiao>que;
   
   

   
   

    
        mazes[x][y]=1;
   
   

   
   

    
        while(!que.empty())
   
   

   
   

    
            switch (maze1[tmpi][tmpj])
   
   

   
   

    
        {
   
   

   
   

    
            zb=que.front();
   
   

   
   

    
            que.pop();
   
   

   
   

    
            int tmpi=zb.i,tmpj=zb.j;
   
   

   
   

    
            {
   
   

   
   

    
                    if(tmpi+zuobiaos[i].i>=0&&tmpi+zuobiaos[i].i<=M&&
   
   

   
   

    
                case 1:
   
   

   
   

    
                for(int i=0;i<4;i++)
   
   

   
   

    
                {
   
   

   
   

    
                        if(!mazes[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]&&
   
   

   
   

    
                    tmpj+zuobiaos[i].j>=0&&tmpj+zuobiaos[i].j<=N)
   
   

   
   

    
                    {
   
   

   
   

    
                            mazes[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]=1;
   
   

   
   

    
                        maze1[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]!=0)
   
   

   
   

    
                        {
   
   

   
   

    
                break;
   
   

   
   

    
                            zb.i=tmpi+zuobiaos[i].i;
   
   

   
   

    
                            zb.j=tmpj+zuobiaos[i].j;
   
   

   
   

    
                        }
   
   

   
   

    
                            que.push(zb);
   
   
          }
            }

   
   

    
                    {
   
   

   
   

    
                case 2:
   
   

   
   

    
                 for(int i=2;i<4;i++)
   
   

   
   

    
                    if(tmpi+zuobiaos[i].i>=0&&tmpi+zuobiaos[i].i<=M&&
   
   

   
   

    
                {
   
   

   
   

    
                    tmpj+zuobiaos[i].j>=0&&tmpj+zuobiaos[i].j<=N)
   
   

   
   

    
                            mazes[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]=1;
   
   

   
   

    
                        if(!mazes[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]&&
   
   

   
   

    
                        maze1[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]!=0)
   
   

   
   

    
                    if(tmpi+zuobiaos[i].i>=0&&tmpi+zuobiaos[i].i<=M&&
   
   

   
   

    
                        {
   
   

   
   

    
                            zb.i=tmpi+zuobiaos[i].i;
   
   

   
   

    
                            zb.j=tmpj+zuobiaos[i].j;
   
   

   
   

    
                            que.push(zb);
   
   

   
   

    
                }
   
   

   
   

    
                        }
   
   
                }

   
   

    
                {
   
   
            break;
            case 3:

   
   

    
                 for(int i=0;i<2;i++)
   
   

   
   

    
                            mazes[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]=1;
   
   

   
   

    
                    tmpj+zuobiaos[i].j>=0&&tmpj+zuobiaos[i].j<=N)
   
   

   
   

    
                    {
   
   

   
   

    
                        if(!mazes[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]&&
   
   

   
   

    
                        maze1[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]!=0)
   
   

   
   

    
                    if(tmpi+zuobiaos[i].i>=0&&tmpi+zuobiaos[i].i<=M&&
   
   

   
   

    
                        {
   
   

   
   

    
                            zb.i=tmpi+zuobiaos[i].i;
   
   

   
   

    
                            que.push(zb);
   
   

   
   

    
                            zb.j=tmpj+zuobiaos[i].j;
   
   
                    }
                }

   
   

    
                {
   
   

   
   

    
                }
   
   

   
   

    
                break;
   
   

   
   

    
                case 4:
   
   

   
   

    
                 for(int i=1;i<2;i++)
   
   

   
   

    
                            mazes[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]=1;
   
   

   
   

    
                    tmpj+zuobiaos[i].j>=0&&tmpj+zuobiaos[i].j<=N)
   
   

   
   

    
                    {
   
   

   
   

    
                        if(!mazes[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]&&
   
   

   
   

    
                        maze1[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]!=0)
   
   

   
   

    
        memset(mazet,0,sizeof(mazet));
   
   

   
   

    
                        {
   
   

   
   

    
                            zb.i=tmpi+zuobiaos[i].i;
   
   

   
   

    
                            zb.j=tmpj+zuobiaos[i].j;
   
   

   
   

    
                            que.push(zb);
   
   

   
   

    
                }
   
   

   
   

    
                        }
   
   
                }

   
   

    
            return true;
   
   
            break;
        }

   
   

    
        if(mazes[tx][ty])
   
   
    }
    {

   
   

    
        zuobiao zb(x,y);
   
   
    }
    else

   
   

    
            return false;
   
   
}

   
   

    
    bool bfst(int x,int y)
   
   
{
    queue<zuobiao>que;

   
   

    
                    tmpj+zuobiaos[i].j>=0&&tmpj+zuobiaos[i].j<=N)
   
   

   
   

    
        mazet[x][y]=1;
   
   

   
   

    
        que.push(zb);
   
   

   
   

    
        while(!que.empty())
   
   

   
   

    
        {
   
   

   
   

    
            zb=que.front();
   
   

   
   

    
            int tmpi=zb.i,tmpj=zb.j;
   
   

   
   

    
            que.pop();
   
   

   
   

    
                case 1:
   
   

   
   

    
            switch (maze1[tmpi][tmpj])
   
   
        {

   
   

    
                    if(tmpi+zuobiaos[i].i>=0&&tmpi+zuobiaos[i].i<=M&&
   
   

   
   

    
                for(int i=0;i<4;i++)
   
   
            {
                {

   
   

    
                            que.push(zb);
   
   

   
   

    
                        if(!mazet[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]&&
   
   

   
   

    
                        maze1[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]!=0)
   
   

   
   

    
                            mazet[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]=1;
   
   

   
   

    
                        {
   
   

   
   

    
                            zb.i=tmpi+zuobiaos[i].i;
   
   

   
   

    
                }
   
   

   
   

    
                            zb.j=tmpj+zuobiaos[i].j;
   
   
                    }
                }

   
   

    
                            mazet[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]=1;
   
   
            break;

   
   

    
                case 2:
   
   

   
   

    
                 for(int i=2;i<4;i++)
   
   

   
   

    
                {
   
   

   
   

    
                    if(tmpi+zuobiaos[i].i>=0&&tmpi+zuobiaos[i].i<=M&&
   
   

   
   

    
                    tmpj+zuobiaos[i].j>=0&&tmpj+zuobiaos[i].j<=N)
   
   
                {

   
   

    
                        maze1[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]!=0)
   
   

   
   

    
                        if(!mazet[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]&&
   
   
                    {
                        zb.i=tmpi+zuobiaos[i].i;

   
   

    
                        if(!mazet[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]&&
   
   

   
   

    
                            zb.j=tmpj+zuobiaos[i].j;
   
   

   
   

    
                            que.push(zb);
   
   

   
   

    
                }
   
   

   
   

    
                        }
   
   
                }

   
   

    
                {
   
   
            break;
            case 3:

   
   

    
                 for(int i=0;i<2;i++)
   
   

   
   

    
                    tmpj+zuobiaos[i].j>=0&&tmpj+zuobiaos[i].j<=N)
   
   

   
   

    
                    if(tmpi+zuobiaos[i].i>=0&&tmpi+zuobiaos[i].i<=M&&
   
   
                {

   
   

    
                    tmpj+zuobiaos[i].j>=0&&tmpj+zuobiaos[i].j<=N)
   
   

   
   

    
                        maze1[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]!=0)
   
   
                    {

   
   

    
                            mazet[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]=1;
   
   

   
   

    
                            zb.i=tmpi+zuobiaos[i].i;
   
   

   
   

    
                            que.push(zb);
   
   

   
   

    
                            zb.j=tmpj+zuobiaos[i].j;
   
   
                    }
                }

   
   

    
                {
   
   

   
   

    
                }
   
   

   
   

    
                break;
   
   

   
   

    
                case 4:
   
   

   
   

    
                 for(int i=1;i<2;i++)
   
   

   
   

    
                        if(!mazet[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]&&
   
   

   
   

    
                    if(tmpi+zuobiaos[i].i>=0&&tmpi+zuobiaos[i].i<=M&&
   
   
                {

   
   

    
        memset(mazes,0,sizeof(mazes));
   
   

   
   

    
                        maze1[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]!=0)
   
   

   
   

    
                        {
   
   

   
   

    
                            mazet[tmpi+zuobiaos[i].i][tmpj+zuobiaos[i].j]=1;
   
   

   
   

    
                            zb.i=tmpi+zuobiaos[i].i;
   
   

   
   

    
                        }
   
   

   
   

    
                            zb.j=tmpj+zuobiaos[i].j;
   
   
                        que.push(zb);

   
   

    
            return 1;
   
   

   
   

    
                    }
   
   
            }

   
   

    
                break;
   
   
        }
    }

   
   

    
    

   
   
    if(mazet[tx][ty])
    else

   
   

    
            return 0;
   
   
}
int main()
{



   
   

    
        memset(maze1,0,sizeof(maze1));
   
   
    memset(mazet,0,sizeof(mazet));

   
   

    
                    sx=i;
   
   

   
   

    
        char tmp;
   
   

   
   

    
        cin>>M>>N;
   
   

   
   

    
        for(int i=0;i<M;i++)
   
   

   
   

    
        {
   
   

   
   

    
            for(int j=0;j<N;j++)
   
   

   
   

    
            {
   
   

   
   

    
                cin>>tmp;
   
   

   
   

    
                {
   
   

   
   

    
                switch(tmp)
   
   

   
   

    
                    case '#':
   
   

   
   

    
                    case '+':
   
   

   
   

    
                    maze1[i][j]=0;
   
   
                break;

   
   

    
                    maze1[i][j]=2;
   
   

   
   

    
                    maze1[i][j]=1;
   
   
                break;

   
   

    
                    break;
   
   
                case '-':
                break;

   
   

    
                    case '|':
   
   
                maze1[i][j]=3;

   
   

    
                    case 'S':
   
   

   
   

    
                    case '.':
   
   

   
   

    
                    maze1[i][j]=4;
   
   
                break;

   
   

    
    }
   
   
                sy=j;

   
   

    
                    maze1[i][j]=1;
   
   

   
   

    
                    break;
   
   

   
   

    
                    tx=i;
   
   

   
   

    
                    case 'T':
   
   
                ty=j;

   
   

    
                    break;
   
   

   
   

    
                    maze1[i][j]=1;
   
   
            }
        }
    }

   
   

    
        int sum=0;
   
   

   
   

    
        if(!bfss(sx,sy))
   
   
    {

   
   

    
            cout<<"I'm stuck!";
   
   
        return 0;
    }

   
   

    
                if(mazes[i][j])
   
   

   
   

    
        for(int i=0;i<M;i++)
   
   
    {

   
   

    
            for(int j=0;j<N;j++)
   
   
        {
            {

   
   

    
            }
   
   

   
   

    
                    if(!bfst(i,j))
   
   
                {

   
   

    
                    }
   
   
                sum++;
            }

   
   

    
        return 0;
   
   
    }
    cout<<sum;


THU-xlj
关注
专栏目录
ccf_I'm stuck!
wsxiaofeioo的博客
01-30 399
问题描述 　　给定一个R行C列的地图，地图的每一个方格可能是'#', '+', '-', '|', '.', 'S', 'T'七个字符中的一个，分别表示如下意思： 　　'#': 任何时候玩家都不能移动到此方格； 　　'+': 当玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格； 　　'-': 当玩家到达这一方格后，下一步可以向左右两个方向相邻的一个非'#'方格移...
CCF/CSP-201312（第0次）
Sigmoid
01-29 81
1. 出现次数最多的数 #include <iostream> #include <map> #define INF 0x3f3f3f3f using namespace std; int main(){ int n, ans = INF, count = 0; map<int,int> mp; cin >> n; while(n--){ int v; cin &g
201312-5 I'm stuck!
qq_23934649的博客
12-05 273
1、深搜找到起点可以到达的所有点，如果其中不包括终点，输入I'm stuck 2、深搜每一个起点可到达的点，如果其不可以到达终点，计数器加一 奉上java满分代码 import java.util.Scanner; public class Main { private static char[][] map; private static int r, c; ...
201312-5 I’m stuck!
程序人生
08-22 306
这个很一般的DFS告诉我们，如果两个遍历的规则差太多的话，还是别想着和到一起写，就可以省去很多麻烦 #include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;cstring&gt; using namespace std; /* 出现编译错误的原因肯定是缺少了头文件，这里没有加csting，memset是其中函数 ...
I’m stuck!
皮皮blog
09-20 2427
http://blog.csdn.net/pipisorry/article/details/39436345 时间限制： 1.0s  内存限制： 256.0MB  问题描述 给定一个R行C列的地图，地图的每一个方格可能是'#', '+', '-', '|','.','S', 'T'七个字符中的一个，分别表示如下意思： '#': 任何时候玩家都不能移动到此方格； '+
CCF-CSP-4-5
最新发布
qq_52825481的博客
04-19 1744
无
CCF-CSP-2013年12月-题解
Never say never
12-11 2321
①出现次数最多的数 问题描述 　　给定n个正整数，找出它们中出现次数最多的数。如果这样的数有多个，请输出其中最小的一个。 输入格式 　　输入的第一行只有一个正整数n(1 ≤ n ≤ 1000)，表示数字的个数。 　　输入的第二行有n个整数s1, s2, …, sn (1 ≤ si ≤ 10000, 1 ≤ i ≤ n)。相邻的数用空格分隔。 输出格式 　　输出
历年CCF-CSP认证考试题目解法/思想
热门推荐
董公子的博客
12-02 2万+
每年的题难度都不太一样，这一点在16、17年上尤其明显，难度低的时候前两道题就是送分题，加一起15分钟解决，得分样例水的不行。难度高的时候第二题就让你模拟半天，且测试样例诡异无比，测试样例通过可能只=20分，就别说后面3,4题了。 总结一些技术点、难点： 字符串处理上：lcs(最长公共子序列)，kmp（字符串匹配算法），复杂题设计思维+注释，类的设置，数据封装，多重嵌套解法
CCFCSP-知识点分类列表（未完）
TriAlley的博客
04-15 1689
文章目录图BFS字符串处理输入输出STL的使用2019201820172016201520142013 图 BFS 201403-4-无线网络 确定起点与终点的最短路径 201312-5-I’m stuck! 是否连通的检测 字符串处理 输入输出 201312-2 ISBN号码 scanf的格式化输入 STL的使用 201312-3-最大的矩形 2019 试题编号 试题名称 ...
csp认证模拟试题答案（有详细注释）——201312-5（I'm stuck!）
12-29
CCF计算机职业资格认证考试模拟试题答案（有详细注释）：试题编号——201312-5（I'm stuck!），编程语言——Java，代码长度——4.698KB，时间使用——437ms，空间使用——154.4MB。
CCF模拟 I’m stuck!
weixin_30526593的博客
03-20 141
I’m stuck! 时间限制： 1.0s 内存限制： 256.0MB 问题描述 给定一个R行C列的地图，地图的每一个方格可能是'#','+','-','|','.','S','T'七个字符中的一个，分别表示如下意思： '#': 任何时候玩家都不能移动到此方格； '+': 当玩家到达这一方格后，下一步可以...
CCF考试——201312-5I’m stuck!
戴璞微的学习之路
03-16 568
概要 问题描述 　　给定一个R行C列的地图，地图的每一个方格可能是’#’, ‘+’, ‘-‘, ‘|’, ‘.’, ‘S’, ‘T’七个字符中的一个，分别表示如下意思： 　　‘#’: 任何时候玩家都不能移动到此方格； 　　‘+’: 当玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非’#’方格移动一格； 　　‘-‘: 当玩家到达这一方格后，下一步可以向左右两个方向相邻...
CCF I’m stuck（满分代码 + 解题思路 + 技巧总结） 201312-5
一只可爱的小猴子的博客
03-03 762
就是假如你要从(x, y)走到(a, b),你先判断从(a, b)能否走到（x, y),若能，则从（x, y)走到（a,b)如果st1中显示从起点无法到达终点则输出“I’m stuck！所以可以开设两个数组记录是否分别满足上述两个条件。然后同时遍历两个数组，计数满足上述条件点的个数。
I'm stuck! ccf模拟题。
silence401的博客
08-31 1469
ccf模拟题。 I’m stuck! 时间限制： 1.0s 内存限制： 256.0MB 问题描述 给定一个R行C列的地图，地图的每一个方格可能是'#','+','-','|','.','S','T'七个字符中的一个，分别表示如下意思： '#': 任何时候玩家都不能移动到此方格； '+': 当玩家到达这一方格后，下一步可以向上下左右四个方向...
CCF CSP 201312-5 I’m stuck!
Yuhan的博客
10-11 252
试题编号： 201312-5 试题名称： I’m stuck! 时间限制： 1.0s 内存限制： 256.0MB 问题描述： 　　给定一个R行C列的地图，地图的每一个方格可能是'#', '+', '-', '|', '.', 'S', 'T'七个字符中的一个，分别表示如下意思： 　　'#': 任何时候玩家都不能移动到此方格； 　　'+': 当玩家到达这一方格后，...
CCFCSP认证201312-5I’m stuck!满分题解（C++）
qq_34653042的博客
12-12 279
#include<iostream> #include<vector> using namespace std; const int maxmize=51; int r,c; typedef struct{ char site; int visited; vector<pair<int,int> > next; }node; node graph[maxmize][maxmize]; node rgraph[maxmize][maxmize]; ...
CSP_I'm stuck!
Vibrant
12-17 360
问题描述: 给定一个R行C列的地图，地图的每一个方格可能是’#’, ‘+’, ‘-’, ‘|’, ‘.’, ‘S’, ‘T’七个字符中的一个，分别表示如下意思： 　　‘#’: 任何时候玩家都不能移动到此方格； 　　‘+’: 当玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非’#‘方格移动一格； 　　‘-’: 当玩家到达这一方格后，下一步可以向左右两个方向相邻的一个非’#‘方格移动一...
CSP认证201312-5 I’m stuck![C++题解]：dfs、两次dfs
阿正的梦工坊
03-20 331
刷题
2023年NOIP CSP-J CSP-S 初赛学习资料大全
这份学习资料集主要针对 NOIP CSP-J CSP-S 初赛的学习和备考，涵盖了计算机结构与组成、计算机科学速成课、CSP 初赛高频考点解析、CSP-J 初赛练习、备战 CSP2022 等多个方面的知识点。 计算机结构与组成是计算机...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值