模拟 | POJ2632.Crashing Robots

模拟 | POJ2632.Crashing Robots

Link：Crashing Robots

Description
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

Source
Nordic 2005

题意
有N个机器人在房间里搬运货物，房间大小为AXB，N个机器人编号为1,2 … N，给出每个机器人的初试位置和方向，以及每个机器人接收的指令，判断机器人是否会撞墙或者互相碰撞。(机器人不会同时移动，每个机器人只有在其他机器人接收指令完成移动过后才会移动)
指令格式如下：
< 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.

样例一解释

5 4		//房间长宽
2 2		//2个机器人  2个指令
1 1 E	//第1个机器人的坐标和初始朝向
5 4 W
1 F 7	第1个机器人接收指令 向前移动7个单位
2 F 7

思路
用二维数组模拟房间号，起始下标为(1,1)，每个坐标存储机器人的编号，若没有机器人则编号为0。模拟指令的执行过程即可。再设置一个robats数组存储机器人的坐标和方向。这样可以根据机器人编号寻找它的坐标，也可以根据坐标判断是否有机器人以及它的编号。
小贴士
1.用数组fwx[4] = {0, 1, 0, -1};fwy[4] = {1, 0, -1, 0};进行坐标的方向移动
2.方向用0，1，2，3表示
左转：robats[seq].dir = (robats[seq].dir+3*rpt)%4;
右转：robats[seq].dir = (robats[seq].dir+rpt)%4;

代码

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

int warehouse[102][102];
int A, B;
int N, M;

struct robat
{
    int x, y;
    int dir;
};
robat robats[101];

int seq;
char ins;
int rpt;

int fwx[4] = {0, 1, 0, -1};
int fwy[4] = {1, 0, -1, 0};

int main()
{
    int cases;
    cin >> cases;
    while( cases-- )
    {
        memset( warehouse, false, sizeof(warehouse) );

        cin >> A >> B;
        cin >> N >> M;
        int _x, _y;
        char _dir;
        //输入N个机器人的初始位置和方向
        for( int i = 1; i <= N; i++ )
        {
            cin >> _x >> _y >> _dir;
            robats[i].x = _x;
            robats[i].y = _y;
            switch( _dir )
            {
                case 'E': robats[i].dir = 1; break;
                case 'S': robats[i].dir = 2; break;
                case 'W': robats[i].dir = 3; break;
                case 'N': robats[i].dir = 0; break;
            }
            warehouse[_x][_y] = i;
        }
        //输入M条指令并执行
        bool flag = true;
        for( int i = 0; i < M; i++ )
        {
            cin >> seq >> ins >> rpt;
            if( ins == 'L' )
                robats[seq].dir = (robats[seq].dir+3*rpt)%4;
            else if( ins == 'R' )
                robats[seq].dir = (robats[seq].dir+rpt)%4;
            else if( flag )
            {
                //判断是否发生碰撞
                for( int j = 1; j <= rpt; j++ )
                {
                    int newx = robats[seq].x + j * fwx[robats[seq].dir];
                    int newy = robats[seq].y + j * fwy[robats[seq].dir];
                    if( newx <= 0 || newx > A || newy <= 0 || newy > B )
                    {
                        cout << "Robot "<< seq << " crashes into the wall" << endl;
                        flag = false;
                        break;
                    }
                    else if( warehouse[newx][newy] )
                    {
                        cout << "Robot " << seq << " crashes into robot " << warehouse[newx][newy] << endl;
                        flag = false;
                        break;
                    }
                }
                //未发生碰撞则移动机器人
                if( flag )
                {
                    warehouse[robats[seq].x][robats[seq].y] = 0;
                    robats[seq].x = robats[seq].x + rpt * fwx[robats[seq].dir];
                    robats[seq].y = robats[seq].y + rpt * fwy[robats[seq].dir];
                    warehouse[robats[seq].x][robats[seq].y] = seq;
                }
            }
        }
        if( flag )
            cout << "OK" << endl;
    }
    return 0;
}