CCF CSP 中国计算机学会-CCF计算机软件能力认证（计算机水平测试）-I’m stuck!- 201312-5

最新推荐文章于 2024-04-25 12:14:05 发布
最新推荐文章于 2024-04-25 12:14:05 发布
阅读量415 收藏
点赞数
分类专栏： CCF CSP c # 广搜 文章标签： CCF CSP I’m stuck! 201312-5 迷宫问题 广搜
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tureful/article/details/103886365
版权
c 同时被 3 个专栏收录
6 篇文章 0 订阅
订阅专栏
CCF CSP
3 篇文章 2 订阅
订阅专栏
广搜
1 篇文章 0 订阅
订阅专栏

问题描述

试题编号：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

 

我的答案：

思路：

从初始点，利用广度优先搜索，走迷宫，将能到达的点视为起始点，放入函数中，看其能否走到终点，如果不能则为符合条件的点。

代码：

#include <stdio.h>
#include <string.h>
typedef struct {
    int x;
    int y;
    char data;
}Point ;
typedef struct {
    Point points[10000];
    int top;
}Way;
int getWay(char (*ch)[51],int r,int c,int now_r,int now_c);//找寻出口
void doit(char (*ch)[51],int r,int c);//计算到不了出口的点数
int main() {
    int r,c;//r行c列的地图
    int i;
    char map[1000][51];//存放地图
    scanf("%d %d",&r,&c);
    getchar();
    for(i=0;i<r;i++)
        gets(map[i]);
    doit(map,r,c);
    return 0;
}
void doit(char (*ch)[51],int r,int c){
    int sum=0;//计数，标记从初始位置可走到但到不了终点的点数
    int flag=0;//标记是否到达出口
    int i,j,now_r,now_c;//现在的位置
    char map[1000][51];
    Way way;//定义一个栈
    Point temp;
    way.top=0;
    for(i=0;i<r;i++){
        for(j=0;j<=c;j++){
            map[i][j]=ch[i][j];
            if(ch[i][j]=='S')
                now_r=i,now_c=j;
        }
    }
    /*
     * 入栈操作，将起始点入栈
     */
    way.points[way.top].x=now_r;
    way.points[way.top].y=now_c;
    way.points[way.top].data=map[now_r][now_c];
    way.top++;
    map[now_r][now_c]='*';
    while(way.top) {
        /*
         * 出栈操作，因为有while在上面，所以栈顶一定会大于零，故不用判断栈为零的情况
         */
        way.top--;
        temp=way.points[way.top];
        if(getWay(ch,r,c,temp.x,temp.y)==0)
            sum++;
        switch (temp.data) {
            case 'T':
            flag=1;
            case '+':
            case 'S':
                if(temp.x>0&&map[temp.x-1][temp.y]!='#'&&map[temp.x-1][temp.y]!='*'){
                    /*
                     * 入栈操作，将出栈点的上面的点入栈
                     */
                    way.points[way.top].x=temp.x-1;
                    way.points[way.top].y=temp.y;
                    way.points[way.top].data=map[temp.x-1][temp.y];
                    way.top++;
                    map[temp.x-1][temp.y]='*';
                }
                if(temp.y<c-1&&(map[temp.x][temp.y+1]!='#')&&(map[temp.x][temp.y+1]!='*')){
                    /*
                     * 入栈操作，将出栈点的右面的点入栈
                     */
                    way.points[way.top].x=temp.x;
                    way.points[way.top].y=temp.y+1;
                    way.points[way.top].data=map[temp.x][temp.y+1];
                    way.top++;
                    map[temp.x][temp.y+1]='*';
                }
                if(temp.x<r-1&&map[temp.x+1][temp.y]!='#'&&map[temp.x+1][temp.y]!='*'){
                    /*
                     * 入栈操作，将出栈点的下面的点入栈
                     */
                    way.points[way.top].x=temp.x+1;
                    way.points[way.top].y=temp.y;
                    way.points[way.top].data=map[temp.x+1][temp.y];
                    way.top++;
                    map[temp.x+1][temp.y]='*';
                }
                if(temp.y>0&&map[temp.x][temp.y-1]!='#'&&map[temp.x][temp.y-1]!='*'){
                    /*
                     * 入栈操作，将出栈点的左面的点入栈
                     */
                    way.points[way.top].x=temp.x;
                    way.points[way.top].y=temp.y-1;
                    way.points[way.top].data=map[temp.x][temp.y-1];
                    way.top++;
                    map[temp.x][temp.y-1]='*';
                }
                break;
            case '-':
                if(temp.y<c-1&&map[temp.x][temp.y+1]!='#'&&map[temp.x][temp.y+1]!='*'){
                    /*
                     * 入栈操作，将出栈点的右面的点入栈
                     */
                    way.points[way.top].x=temp.x;
                    way.points[way.top].y=temp.y+1;
                    way.points[way.top].data=map[temp.x][temp.y+1];
                    way.top++;
                    map[temp.x][temp.y+1]='*';
                }
                if(temp.y>0&&map[temp.x][temp.y-1]!='#'&&map[temp.x][temp.y-1]!='*'){
                    /*
                     * 入栈操作，将出栈点的左面的点入栈
                     */
                    way.points[way.top].x=temp.x;
                    way.points[way.top].y=temp.y-1;
                    way.points[way.top].data=map[temp.x][temp.y-1];
                    way.top++;
                    map[temp.x][temp.y-1]='*';
                }
                break;
            case '|':
                if(temp.x>0&&map[temp.x-1][temp.y]!='#'&&map[temp.x-1][temp.y]!='*'){
                    /*
                     * 入栈操作，将出栈点的上面的点入栈
                     */
                    way.points[way.top].x=temp.x-1;
                    way.points[way.top].y=temp.y;
                    way.points[way.top].data=map[temp.x-1][temp.y];
                    way.top++;
                    map[temp.x-1][temp.y]='*';
                }
                if(temp.x<r-1&&map[temp.x+1][temp.y]!='#'&&map[temp.x+1][temp.y]!='*'){
                    /*
                     * 入栈操作，将出栈点的下面的点入栈
                     */
                    way.points[way.top].x=temp.x+1;
                    way.points[way.top].y=temp.y;
                    way.points[way.top].data=map[temp.x+1][temp.y];
                    way.top++;
                    map[temp.x+1][temp.y]='*';
                }
                break;
            case '.':
                if(temp.x<r-1&&map[temp.x+1][temp.y]!='#'&&map[temp.x+1][temp.y]!='*'){
                    /*
                     * 入栈操作，将出栈点的下面的点入栈
                     */
                    way.points[way.top].x=temp.x+1;
                    way.points[way.top].y=temp.y;
                    way.points[way.top].data=map[temp.x+1][temp.y];
                    way.top++;
                    map[temp.x+1][temp.y]='*';
                }
                break;
        }
    }
    if(flag==0){
        printf("I'm stuck!\n");
    } else{
        printf("%d\n",sum);
    }
}
int getWay(char (*ch)[51],int r,int c,int now_r,int now_c){
    int flag=0;//标记是否到达出口
    int i,j;//现在的位置
    char map[1000][51];
    Way way;//定义一个字符栈
    Point temp;
    way.top=0;
    for(i=0;i<r;i++){
        for(j=0;j<=c;j++){
            map[i][j]=ch[i][j];
        }
    }
    /*
     * 入栈操作，将起始点入栈
     */
    way.points[way.top].x=now_r;
    way.points[way.top].y=now_c;
    way.points[way.top].data=map[now_r][now_c];
    way.top++;
    map[now_r][now_c]='*';
    while(way.top) {
        /*
         * 出栈操作，因为有while在上面，所以栈顶一定会大于零，故不用判断栈为零的情况
         */
        way.top--;
        temp=way.points[way.top];
        switch (temp.data) {
            case '+':
            case 'S':
                if(temp.x>0&&map[temp.x-1][temp.y]!='#'&&map[temp.x-1][temp.y]!='*'){
                    /*
                     * 入栈操作，将出栈点的上面的点入栈
                     */
                    way.points[way.top].x=temp.x-1;
                    way.points[way.top].y=temp.y;
                    way.points[way.top].data=map[temp.x-1][temp.y];
                    way.top++;
                    map[temp.x-1][temp.y]='*';
                }
                if(temp.y<c-1&&map[temp.x][temp.y+1]!='#'&&map[temp.x][temp.y+1]!='*'){
                    /*
                     * 入栈操作，将出栈点的右面的点入栈
                     */
                    way.points[way.top].x=temp.x;
                    way.points[way.top].y=temp.y+1;
                    way.points[way.top].data=map[temp.x][temp.y+1];
                    way.top++;
                    map[temp.x][temp.y+1]='*';
                }
                if(temp.x<r-1&&map[temp.x+1][temp.y]!='#'&&map[temp.x+1][temp.y]!='*'){
                    /*
                     * 入栈操作，将出栈点的下面的点入栈
                     */
                    way.points[way.top].x=temp.x+1;
                    way.points[way.top].y=temp.y;
                    way.points[way.top].data=map[temp.x+1][temp.y];
                    way.top++;
                    map[temp.x+1][temp.y]='*';
                }
                if(temp.y>0&&map[temp.x][temp.y-1]!='#'&&map[temp.x][temp.y-1]!='*'){
                    /*
                     * 入栈操作，将出栈点的左面的点入栈
                     */
                    way.points[way.top].x=temp.x;
                    way.points[way.top].y=temp.y-1;
                    way.points[way.top].data=map[temp.x][temp.y-1];
                    way.top++;
                    map[temp.x][temp.y-1]='*';
                }
                break;
            case '-':
                if(temp.y<c-1&&map[temp.x][temp.y+1]!='#'&&map[temp.x-1][temp.y+1]!='*'){
                    /*
                     * 入栈操作，将出栈点的右面的点入栈
                     */
                    way.points[way.top].x=temp.x;
                    way.points[way.top].y=temp.y+1;
                    way.points[way.top].data=map[temp.x][temp.y+1];
                    way.top++;
                    map[temp.x][temp.y+1]='*';
                }
                if(temp.y>0&&map[temp.x][temp.y-1]!='#'&&map[temp.x][temp.y-1]!='*'){
                    /*
                     * 入栈操作，将出栈点的左面的点入栈
                     */
                    way.points[way.top].x=temp.x;
                    way.points[way.top].y=temp.y-1;
                    way.points[way.top].data=map[temp.x][temp.y-1];
                    way.top++;
                    map[temp.x][temp.y-1]='*';
                }
                break;
            case '|':
                if(temp.x>0&&map[temp.x-1][temp.y]!='#'&&map[temp.x-1][temp.y]!='*'){
                    /*
                     * 入栈操作，将出栈点的上面的点入栈
                     */
                    way.points[way.top].x=temp.x-1;
                    way.points[way.top].y=temp.y;
                    way.points[way.top].data=map[temp.x-1][temp.y];
                    way.top++;
                    map[temp.x-1][temp.y]='*';
                }
                if(temp.x<r-1&&map[temp.x+1][temp.y]!='#'&&map[temp.x+1][temp.y]!='*'){
                    /*
                     * 入栈操作，将出栈点的下面的点入栈
                     */
                    way.points[way.top].x=temp.x+1;
                    way.points[way.top].y=temp.y;
                    way.points[way.top].data=map[temp.x+1][temp.y];
                    way.top++;
                    map[temp.x+1][temp.y]='*';
                }
                break;
            case '.':
                if(temp.x<r-1&&map[temp.x+1][temp.y]!='#'&&map[temp.x+1][temp.y]!='*'){
                    /*
                     * 入栈操作，将出栈点的下面的点入栈
                     */
                    way.points[way.top].x=temp.x+1;
                    way.points[way.top].y=temp.y;
                    way.points[way.top].data=map[temp.x+1][temp.y];
                    way.top++;
                    map[temp.x+1][temp.y]='*';
                }
                break;
            case 'T':
            flag=1;
            way.top=0;
        }
    }
    return flag;
}

自我评价

成绩70分，说明过了7组测试数据，还有三组测试数据没有过，暂时不知道原因，希望大佬指正讨论

九僧
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CCF CSP 201312-5 I’m stuck! (Python)
q415827717的博客
08-24 139
问题描述 　　给定一个R行C列的地图，地图的每一个方格可能是'#', '+', '-', '|', '.', 'S', 'T'七个字符中的一个，分别表示如下意思： 　　'#': 任何时候玩家都不能移动到此方格； 　　'+': 当玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格； 　　'-': 当玩家到达这一方格后，下一步可以向左右两个方向相邻的一个非'#'方格移动一格； 　　'|': 当玩家到达这一方格后，下一步可以向上下两个方向相邻的一个非'#'方格移动一格； 　　'.
2019CCF非专业级别软件能力认证第一轮CSP-J 答案及解析.docx
09-10
以上是针对2019CCF非专业级别软件能力认证第一轮CSP-J答案及解析中的主要知识点的详细解释，涵盖了数据结构、算法、逻辑推理等多个方面，这些都是信息学竞赛和软件能力认证中常见的考查点。学习这些知识点有助于提升...
CCF-CSP认证历年真题解
热门推荐
海岛Blog
01-28 32万+
CSP认证考什么怎么考？ CCF计算机职业资格认证的每一道试题都十分经典，覆盖现实世界中方方面面的问题。这个历年试题解主要使用C/C++语言编写，将逐步增加Python和Java的解题程序。程序中附有注释，力求解题思路清晰简洁，值得珍藏与模仿。 逐题改写过程中，富文本编辑器写的博客将全部用Markdown编辑器改写。改写的第一题，都增加了Python和Java的解题程序。 2021.04第22次： CCF202104-1 灰度直方图（100分）【计数】 CCF202104-2 邻域均值（100分.
CCF-CSP 201312-5 I‘m stuck! (python)
xbr_1111的博客
02-15 240
201312-5[I’m stuck!] 问题描述 问题描述 给定一个R行C列的地图，地图的每一个方格可能是’#’, ‘+’, ‘-’, ‘|’, ‘.’, ‘S’, ‘T’七个字符中的一个，分别表示如下意思： 　　‘#’: 任何时候玩家都不能移动到此方格； 　　‘+’: 当玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非’#‘方格移动一格； 　　‘-’: 当玩家到达这一方格后，下一步可以向左右两个方向相邻的一个非’#‘方格移动一格； 　　‘|’: 当玩家到达这一方格后，下一步可以向上下两个
CCF CSP认证201312-5 I'm stuck!（DFS）
weixin_43944910的博客
08-18 266
201312-5 I’m stuck! 问题描述　 给定一个R行C列的地图，地图的每一个方格可能是’#’, ‘+’, ‘-’, ‘|’, ‘.’, ‘S’, ‘T’七个字符中的一个，分别表示如下意思： 　　‘#’: 任何时候玩家都不能移动到此方格； 　　‘+’: 当玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非’#‘方格移动一格； 　　‘-’: 当玩家到达这一方格后，下一步可以向...
CCF 201312-5 I’m stuck!
zjw123king的博客
04-06 915
//主要利用宽度优先算法。把S出发的能够到达的点都保存栈中。然后遍历所有栈中的点，调用bfs算法，看是否能到达终点。如果能计数 //sum++.  所有最后的点就是 能够到达的点减去sum   再减去1（因为T在栈中时，不计数sum） #include #include #include #include #include #include #include us
CCFCSP-201312-5-I’m stuck!
TriAlley的博客
04-14 437
提交前忘记去掉freopen，为这个调试了整整一上午... 下午继续提交，老是超时，把所有STL元素都去掉之后，不超时了，不仅不超时，还快得一匹... 再精简一下代码就行了，刷题一时爽，一直刷一直爽 试题编号： 201312-5 试题名称： I’m stuck! 时间限制： 1.0s 内存限制： 256.0MB 问题描述： 问题描述...
CCF-CSP真题题解：201312-5 I’m stuck!
最新发布
Hyperplasma
04-25 146
DFS
CCF CSP2013-12-5 I‘m stuck!
weixin_43476775的博客
03-31 90
CSP2013-12-5 I’m stuck! 思路：使用两次BFS。注意第二个条件是不可以从此方格移动到目标位置，可以将所有有向边翻转，然后转化为不可以从目标位置移动到此方格。所以要建两个图，这里使用邻接表存储。 第一次BFS，以S为出发点，标记所有从S能到达的点。对于方格u，若从方格u可移动一格到v(v!=’#’)，则添加有向边(u,v)。注意：因为T不是出发点，所以u包括T。 第二次BFS，从T点出发，标记从T能到达的点。对于方格u，若从u移动一格可以到v(v!=’#’)，则添加有向边(v,u)
CCFCSP认证201312-5I’m stuck!满分题解（C++）
qq_34653042的博客
12-12 274
#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认证模拟试题答案（有详细注释）——201312-5（I'm stuck!）
12-29
CCF计算机职业资格认证考试模拟试题答案（有详细注释）：试题编号——201312-5（I'm stuck!），编程语言——Java，代码长度——4.698KB，时间使用——437ms，空间使用——154.4MB。
CCF CSP 计算机软件能力认证第1-13次真题20180709更新
12-29
CCF CSP 计算机软件能力认证第1-13次真题20180709更新
2021 CCF 非专业级别软件能力认证第一轮（CSP-S1）提高级 C++语言试题.pdf
09-20
2021 CCF 非专业级别软件能力认证第一轮（CSP-S1）提高级 C++语言试题.pdf
CCF CSP（CCF计算机软件能力认证）&& CCSP_pdf-2021.01.10.rar
01-10
CCF CSP（CCF计算机软件能力认证）&& CCSP_pdf-2021.01.10.rar
课程实践——第二个——歌手大赛评分系统
tureful的博客
01-06 5789
/* Copyright (c) 2016, 烟台大学计算机学院 All rights reserved. 文件名称：first.cpp 作 者：颜丙齐 完成日期：2017年 1 月 6 日 版 本 号：v1.0 题目描述 歌手大赛计分系统 输入 　评委个数和每位评委的打分 输出 　选手的平均得分 样例输入 4 1 2 3 4 样例输出 　这是歌手大赛的计分系...
CCF CSP 中国计算机学会-CCF计算机软件能力认证（计算机水平测试）- 最大的矩形- 201312-3
tureful的博客
01-08 465
问题描述 试题编号： 201312-3 试题名称： 最大的矩形 时间限制： 1.0s 内存限制： 256.0MB 问题描述： 问题描述 　　在横轴上放了n个相邻的矩形，每个矩形的宽度是1，而第i（1 ≤ i ≤ n）个矩形的高度是hi。这n个矩形构成了一个直方图。例如，下图中六个矩形的高度就分别是3, 1, 6, 5, 2, 3。 ...
2312：顺序排列【数组】。
tureful的博客
09-09 378
题目描述 编写一个过程，对一个n×n的矩阵，通过行变换，使其每行元素的平均值按递增顺序排列 输入 4 5 5 5 5 4 4 4 4 3 3 3 3 1 1 1 1 输出 1 1 1 1 3 3 3 3 4 4 4 4 5 5 5 5 样例输入 <span style="color:#333333">3 1 2 3 4 5 6 1 1 1</span...
1006: Hero In Maze
tureful的博客
09-07 172
题目描述 500年前，Jesse是我国最卓越的剑客。他英俊潇洒，而且机智过人^_^。 突然有一天，Jesse心爱的公主被魔王困在了一个巨大的迷宫中。Jesse听说这个消息已经是两天以后了，他知道公主在迷宫中还能坚持T天，他急忙赶到迷宫，开始到处寻找公主的下落。 时间一点一点的过去，Jesse还是无法找到公主。最后当他找到公主的时候，美丽的公主已经死了。从此Jesse郁郁寡欢，茶饭不思，一年后追随...
CCF CSP历年真题集：2013-2017，含计算机编程难题
CCF CSP（中国计算机学会软件能力认证）是一项旨在评估个人在计算机软件设计和开发能力的认证考试。这些真题涵盖了多个年度，包括2013年、2014年、2015年、2016年和2017年的不同考试批次，对于准备参加CSP认证的人来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值