模拟 Crashing Robots

最新推荐文章于 2021-07-25 10:46:46 发布
最新推荐文章于 2021-07-25 10:46:46 发布 · 423 阅读 · 0
文章标签：

#模拟题

本文介绍了一种模拟机器人在仓库环境中避免碰撞的算法。通过详细解析输入输出格式、机器人动作指令及碰撞检测逻辑，实现了一个能够处理多个机器人并确保它们在执行任务过程中不发生碰撞的系统。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

In a modernized warehouse, robots are used to fetch the goods. Careful planning is needed to ensure that the robots reach their destinations without crashing into each other. Of course, all warehouses are rectangular, and all robots occupy a circular floor space with a diameter of 1 meter. Assume there are N robots, numbered from 1 through N. You will get to know the position and orientation of each robot, and all the instructions, which are carefully (and mindlessly) followed by the robots. Instructions are processed in the order they come. No two robots move simultaneously; a robot always completes its move before the next one starts moving.
A robot crashes with a wall if it attempts to move outside the area of the warehouse, and two robots crash with each other if they ever try to occupy the same spot.
Input
The first line of input is K, the number of test cases. Each test case starts with one line consisting of two integers, 1 <= A, B <= 100, giving the size of the warehouse in meters. A is the length in the EW-direction, and B in the NS-direction.
The second line contains two integers, 1 <= N, M <= 100, denoting the numbers of robots and instructions respectively.
Then follow N lines with two integers, 1 <= Xi <= A, 1 <= Yi <= B and one letter (N, S, E or W), giving the starting position and direction of each robot, in order from 1 through N. No two robots start at the same position.

Figure 1: The starting positions of the robots in the sample warehouse

Finally there are M lines, giving the instructions in sequential order.
An instruction has the following format:
< robot #> < action> < repeat>
Where is one of
  • L: turn left 90 degrees,
  • R: turn right 90 degrees, or
  • F: move forward one meter,

and 1 <= < repeat> <= 100 is the number of times the robot should perform this single move.
Output
Output one line for each test case:
  • Robot i crashes into the wall, if robot i crashes into a wall. (A robot crashes into a wall if Xi = 0, Xi = A + 1, Yi = 0 or Yi = B + 1.)
  • Robot i crashes into robot j, if robots i and j crash, and i is the moving robot.
  • OK, if no crashing occurs.

Only the first crash is to be reported.
Sample Input 
4
5 4
2 2
1 1 E
5 4 W
1 F 7
2 F 7
5 4
2 4
1 1 E
5 4 W
1 F 3
2 F 1
1 L 1
1 F 3
5 4
2 2
1 1 E
5 4 W
1 L 96
1 F 2
5 4
2 3
1 1 E
5 4 W
1 F 4
1 L 1
1 F 20
Sample Output 
Robot 1 crashes into the wall
Robot 1 crashes into robot 2
OK
Robot 1 crashes into robot 2

第一次写这么长的模拟题把，思路很简单，但是两天才完全搞定，我是跟着思路一步一步来的，这次的坑点主要在

if  else 语句上的失败，

举个例子

if（ok1）

if（ok2）

else

{

}

我原本的意思是想要分三种情况，而上述代码却执行了两种情况，找了半天才找出来。

还有一个也是 if 语句，举个例子

if（dir=='n'）

{

somefunction()...

}

if(dir=='e')

{

...

}

也不能用if，而要用else if

因为可能第一个操作导致dir变成了e，而又执行下一个操作。



注意到这点其他的没什么可说的了，按步骤赖就行。当然我的代码还没优化，可以自己优化。















#include<iostream>
#include<cstdio>
#include<map>
#include<cstring>
using namespace std;
int num;
int n,m;
int p,c,flag,step;
int vis[110][110];
struct Node
{
    int x;
    int y;
    char dir;
} node;
map<int,Node>mp;
void solve()
{
    int tx=node.x;
    int ty=node.y;
    char dir=node.dir;
    int cnt=1;
    int nx=tx,ny=ty;
    //cout<<dir<<" "<<tx<<" "<<ty<<endl;
    if(dir=='W')
    {
        for(int i=tx-1; i>=1&&cnt<=step; --i,++cnt)
        {
            if(vis[i][ty])
            {
                cout<<"Robot "<<num<<" crashes into robot "<<vis[i][ty]<<endl;
                flag=1;
                break;
            }
        }
        if(!flag&&tx-step<1)
        {
            cout<<"Robot "<<num<<" crashes into the wall"<<endl;
            flag=1;
        }
        if(!flag)
        {
            nx=tx-step;
        }
    }
    else if(dir=='N')
    {
        for(int i=ty+1; i<=m&&cnt<=step; ++i,++cnt)
        {
            if(vis[tx][i])
            {
                cout<<"Robot "<<num<<" crashes into robot "<<vis[tx][i]<<endl;
                flag=1;
                break;
            }
        }
        if(!flag&&ty+step>m)
        {
            cout<<"Robot "<<num<<" crashes into the wall"<<endl;
            flag=1;
        }
        if(!flag)
        {
            ny=ty+step;
        }
    }
    else if(dir=='E')
    {
        for(int i=tx+1; i<=n&&cnt<=step; ++i,++cnt)
        {
            if(vis[i][ty])
            {
                cout<<"Robot "<<num<<" crashes into robot "<<vis[i][ty]<<endl;
                flag=1;
                break;
            }
        }
        if(!flag&&tx+step>n)
        {
            cout<<"Robot "<<num<<" crashes into the wall"<<endl;
            flag=1;
        }
        if(!flag)
        {
            nx=tx+step;
        }
    }
    else if(dir=='S')
    {
        //cout<<tx<<" "<<ty<<endl;
        for(int i=ty-1; i>=1&&cnt<=step; --i,++cnt)
        {
            if(vis[tx][i])
            {
                cout<<"Robot "<<num<<" crashes into robot "<<vis[tx][i]<<endl;
                flag=1;
                break;
            }
        }
        if(!flag&&ty-step<1)
        {
            cout<<"Robot "<<num<<" crashes into the wall"<<endl;
            flag=1;
        }
        if(!flag)
        {
            ny=ty-step;
        }
    }
    if(!flag)
    {
        vis[tx][ty]=0;
        vis[nx][ny]=num;
        node.x=nx;
        node.y=ny;
        node.dir=dir;
        mp[num]=node;
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d %d",&n,&m);
        memset(vis,0,sizeof(vis));
        flag=0;
        cin>>p>>c;
        int x,y;
        char d;
        for(int i=1; i<=p; ++i)
        {
            scanf("%d %d %c",&x,&y,&d);
            vis[x][y]=i;
            node.x=x;
            node.y=y;
            node.dir=d;
            mp[i]=node;
        }
        for(int i=1; i<=c; ++i)
        {
            scanf("%d %c %d",&num,&d,&step);
            if(!flag)
            {
                if(d=='L')
                {
                    step%=4;
                    if(step)
                    {
                        if(mp[num].dir=='W')
                        {
                            if(step==1)
                            {
                                mp[num].dir='S';
                            }
                            if(step==2)
                            {
                                mp[num].dir='E';
                            }
                            if(step==3)
                            {
                                mp[num].dir='N';
                            }
                        }
                        else if(mp[num].dir=='N')
                        {
                            if(step==1)
                            {
                                mp[num].dir='W';
                            }
                            if(step==2)
                            {
                                mp[num].dir='S';
                            }
                            if(step==3)
                            {
                                mp[num].dir='E';
                            }
                        }
                        else if(mp[num].dir=='S')
                        {
                            if(step==1)
                            {
                                mp[num].dir='E';
                            }
                            if(step==2)
                            {
                                mp[num].dir='N';
                            }
                            if(step==3)
                            {
                                mp[num].dir='W';
                            }
                        }
                        else  if(mp[num].dir=='E')
                        {
                            if(step==1)
                            {
                                mp[num].dir='N';

                            }
                            if(step==2)
                            {
                                mp[num].dir='W';
                            }
                            if(step==3)
                            {
                                mp[num].dir='S';
                            }
                        }
                    }
                }
                else if(d=='R')
                {
                    step%=4;
                    if(step)
                    {
                        if(mp[num].dir=='W')
                        {
                            if(step==1)
                            {
                                mp[num].dir='N';
                            }
                            if(step==2)
                            {
                                mp[num].dir='E';
                            }
                            if(step==3)
                            {
                                mp[num].dir='S';
                            }
                        }
                        else if(mp[num].dir=='N')
                        {
                            if(step==1)
                            {
                                mp[num].dir='E';
                            }
                            if(step==2)
                            {
                                mp[num].dir='S';
                            }
                            if(step==3)
                            {
                                mp[num].dir='W';
                            }
                        }
                        else if(mp[num].dir=='S')
                        {
                            if(step==1)
                            {
                                mp[num].dir='W';
                            }
                            if(step==2)
                            {
                                mp[num].dir='N';
                            }
                            if(step==3)
                            {
                                mp[num].dir='E';
                            }
                        }
                        else if(mp[num].dir=='E')
                        {
                            if(step==1)
                            {
                                mp[num].dir='S';
                            }
                            if(step==2)
                            {
                                mp[num].dir='W';
                            }
                            if(step==3)
                            {
                                mp[num].dir='N';
                            }
                        }
                    }
                }
                else
                {
                    node=mp[num];
                    solve();
                }
            }
        }
        if(!flag)
            cout<<"OK"<<endl;
    }
}




Crashing Robots (复杂模拟)
一只小菜鸡的博客
08-14 899
In a modernized warehouse, robots are used to fetch the goods. Careful planning is needed to ensure that the robots reach their destinations without crashing into each other. Of course, all warehouses
HDU题目分类大全【大集合】
欢迎来到扣子不会飞的博客！
03-18 3857
基础题： 1000、1001、1004、1005、1008、1012、1013、1014、1017、1019、1021、1028、1029、 1032、1037、1040、1048、1056、1058、1061、1070、1076、1089、1090、1091、1092、1093、 1094、1095、1096、1097、1098、1106、1108、1157、1163、1164、1170、...
UVA 12503 - Robot Instructions
weixin_34124577的博客
08-08 172
12503 - Robot Instructions You have a robot standing on the origin of x axis. The robot will be given some instructions. Your taskis...
poj 2632 Crashing Robots
山隹的博客
04-25 210
模拟题，考验一些细节的东西，但我真的是太笨了，细节方面总是出错。 这一题最关键的是如何用数组表示出这个二维坐标平面，我个人觉得把题目给的图顺时针旋转90度的话，就比较方便。 题源 以下是代码（虽然是从网上看的）： #include <iostream> #include <algorithm> #include <cstdio> #include <map...
Crashing Robots
泰勒猫的博客
07-25 139
Crashing Robots Sample Input： 一道比较复杂的模拟题，一句话：细节决定成败！ 我还是没有对结构体太敏感，以后还是要多用，提高代码的效率！ 代码注释说明一切： （我很长，请你忍一下~）： //麻烦的模拟题 #include<iostream> #include<cstdio> #include<Cstring> using namespace std; //使用结构体更加简洁！（一开始用的数组，菜菜~） struct Robot {
模拟——Crashing Robots
空白页
06-16 525
Crashing Robots Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 7471   Accepted: 3266 Description In a modernized warehouse, robots are used to fetch the goo
poj 2632 Crashing Robots （模拟题）
L-75的专栏
10-16 406
Crashing Robots Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 10286   Accepted: 4362 Description In a modernized warehouse, robots are used to fetch the
J - Crashing Robots
xiaosuC的博客
02-01 290
J - Crashing Robots 文章目录J - Crashing Robots题目描述：Input：Output：Sample Input：Sample Output：题目大意：思路分析：代码： 题目描述： In a modernized warehouse, robots are used to fetch the goods. Careful planning is needed to...
POJ 2632 Crashing Robots【模拟】
DUT_LYH
05-29 216
#include <iostream> using namespace std; #define debug(x) cout<<#x<<": "<<(x)<<endl; #pragma warning(disable:4996) int K, A, B, N, M; int a[1002][1002]; struct rob { int x, y; int d; // n 0 , e 1 }; rob rbs[10
POJ2632-Crashing Robots解题分析与AC代码
北大POJ2632-Crashing Robots是一道经典的编程题，常作为算法和编程能力的测试题出现在各大在线编程平台和算法竞赛中，如北京大学的在线评测系统（PKU Judge Online，简称POJ）。该题目要求参与者利用算法逻辑，编写...
hdu题目分类
10-12
18. **1020 Crashing Robots 模拟题** - **知识点**: 模拟算法。 - **描述**: 模拟机器人的碰撞行为。 - **难度级别**: 中等。 - **解题思路**: 按照题目要求模拟机器人运动过程。 19. **1022 Watchdog 简单题*...
hdoj杭电问题分类
04-02 5582
杭电上的题虽然多，但是一直苦于找不到问题分类，网页都是英文的，所以平时做题也没怎么看，今天仔细一看，问题分类竟然就在主页。。。。做了那么久的题居然没发现，表示已经狗带。。不要笑，不知道有没有像我一样傻的孩子，可以参考一下。。。 点进来就是。。。
字符串模式匹配（简单模式匹配算法与KMP算法）（一）
热门推荐
ices_的博客
09-05 1万+
一般的字符串模式匹配算法是类似下面的逐次匹配，举例说明如下 主串s=ababcabcacbab 从串t=abcac 一般匹配方法如下图所示 代码如下 int index(string s,string t) {     int i=0,j=0;     int l1=s.length();     int l2=t.length();     while(i&lt;=l1-1&amp...
优先队列实现 哈夫曼编码
ices_的博客
05-19 1958
用到了优先队列的知识点，还有dfs算法。 优先队列主要是为了查找最小权重树的时候方便查找，不用耗费很多的时间从已经产生的树种依次查找， 具体实现看代码。 dfs主要是用来遍历树从而拿到每个字符的编码，具体实现看代码 #include #include #include #include using namespace std; //节点树模型 struct Node{ char
回溯旅行商问题
ices_的博客
06-05 1139
#include #include using namespace std; templateclass Traveling{ friend Type TSP(int **,int [],int,Type); public: void Backtrack(int i); int n,//图G的顶点数 *x,//当前解 **bestx,//当前最优解
字符串”水“题
ices_的博客
04-25 1071
题目描述 给出一个长度为n的字符串(1 输入 第一行一个正整数T，表示数据组数(1 接下来T行，每行有一个只包含小写字母的字符串。 输出 每个答案输出满足要求字符串个数。每个答案占一行。 样例输入 3aaabbccabcabc 样例输出 061 这道题用到了字符串的状态压缩 首先来解释一下亦或的用法 举个例子 aba
（简单贪心）Bin Packing
ices_的博客
04-23 1005
A set of n 1-dimensional items have to be packed in identical bins. All bins have exactly the same length l and each item i has length li<=l . We look for a minimal number of bins q such that eac
（优先队列）The Average
ices_的博客
04-27 918
In a speech contest, when a contestant finishes his speech, the judges will then grade his performance. The staff remove the highest grade and the lowest grade and compute the average of the rest as t
多泳道（队列）问题 标准输出问题
ices_的博客
07-17 875
问题描述： 发神给我出的一个题 给出一个数n 输入n个 1-n 的数，不能重复， 求使上述输出的数转换为正序排列的数的最小泳道数 条件： 可以利用多个泳道（也就是队列），每个泳道可以装若干个数 //思路 每个数前面的数只能是比次数小的，不能是比次数大的，如果当前不存在一个泳道的最后一个数小于要加如的数，则size++， //如果存在多个符合条件的，则插入到当前泳道中队尾最大的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值