第六场问题 F: GlitchBot（模拟）

传送门

题目描述

One of our delivery robots is malfunctioning! The job of the robot is simple; it should follow a list of instructions in order to reach a target destination. The list of instructions is originally correct to get the robot to the target. However, something is going wrong as we upload the instructions into the robot’s memory. During the upload, one random instruction from the list takes on a different value than intended. Yes,there is always a single bad instruction in the robot’s memory and it always results in the robot arriving at an incorrect destination as it finishes executing the list of instructions.
The robot can execute the instructions “Left”, “Right”, and “Forward”. The “Left” and “Right” instructions do not result in spatial movement but result in a 90-degree turn in the corresponding direction. “Forward” is the only instruction that results in spatial movement, causing the robot to move one unit in the direction it is facing. The robot always starts at the origin (0, 0) of a grid and faces north along the positive y-axis.
Given the coordinates of the target destination and the list of instructions that the robot has in its memory, you are to identify a correction to the instructions to help the robot reach the proper destination.

输入

The first line of the input contains the x and y integer coordinates of the target destination, where −50 ≤ x ≤ 50 and −50 ≤ y ≤ 50. The following line contains an integer n representing the number of instructions in the list, where 1 ≤ n ≤ 50. The remaining n lines each contain a single instruction. These instructions may be: “Left”, “Forward”, or “Right”.

输出

Identify how to correct the robot’s instructions by printing the line number (starting at 1) of an incorrect input instruction, followed by an instruction substitution that would make the robot reach the target destination. If there are multiple ways to fix the instructions, report the fix that occurs for the earliest line number in the sequence of instructions. There is always exactly one unique earliest fix.

样例输入

复制样例数据

3 2 11 Forward Right Forward Forward Left Forward Forward Left Forward Right Forward

样例输出

8 Right

就按照题意模拟就行了，数据范围也不大，比赛的时候一个队友去模拟，没有模拟出来。

#include<bits/stdc++.h>
using namespace std;
const int MAX = 60;
const int f = -1,l = 0,u = 1,r = 2,d = 3;
const int cx[] = {-1, 0, 1, 0};
const int cy[] = {0, 1, 0, -1};
int ex, ey, n;
struct Step
{
    int oper;
    int state;
    int x, y;
};
Step step[MAX];
bool walk(int x, int y, int number, int state)
{
    for(int i = number; i < n; i++)
    {
        if(step[i].oper == f)
        {
            x += cx[state];
            y += cy[state];
        }
        else if(step[i].oper == r)
            state = (state + 1) % 4;//顺时针
        else
            state = (state + 4 - 1) % 4;//逆时针
    }
    return (x == ex && y == ey);
}

int main()
{
#ifndef ONLINE_JUDGE
    freopen("in","r",stdin);
#endif
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    string str;
    while(cin >> ex >> ey)
    {
        cin >> n;
        int x = 0, y = 0, state = u;
        for(int i = 0; i < n; i++)
        {
            cin >> str;

            step[i].x = x, step[i].y = y, step[i].state = state;
            if(str == "Forward")
            {
                step[i].oper = f;
                x += cx[state];
                y += cy[state];
            }
            else if(str == "Right")
            {
                step[i].oper = r;
                state = (state + 1) % 4;//顺时针
            }
            else
            {
                step[i].oper = l;
                state = (state + 4 - 1) % 4;//逆时针
            }
        }

        for(int i = 0; i < n; i++)
        {
            if(step[i].oper != f && walk(step[i].x + cx[step[i].state], step[i].y + cy[step[i].state], i + 1, step[i].state))
            {
                cout << i + 1 << " Forward" << endl;
                break;
            }
            if(step[i].oper != l && walk(step[i].x, step[i].y, i + 1, (step[i].state + 4 - 1) % 4))
            {
                cout << i + 1 << " Left" << endl;
                break;
            }
            if(step[i].oper != r && walk(step[i].x, step[i].y, i + 1, (step[i].state + 1) % 4))
            {
                cout << i + 1 << " Right" << endl;
                break;
            }
        }
    }
    return 0;
}