山东大学程序设计摘星星

好久没写题解了，颓废了好久的蒟蒻终于决定站起来了

题目大意

shy 喜欢仰望星空，并热衷于收集天上的星星。他把星空抽象成一个二维的平面，并制作了一个大小为 n×m 的地图，经过一段时间的积累，他已经标记了 k 个有星星的位置。

为了收集星星，他制造了一个机器人，来收集这些星星。开始时，机器人位于地图的左上角，坐标为 (1,1) 的位置。当向右走的时候y坐标增大，向下走的时候x坐标增大。

现在他向机器人发出了 t 条指令，每条指令的格式为一 Dir step，Dir 为一个字符，表示方向，step 是一个整数，表示前进的步数。

Dir 只包含四个字符：W,A,S,D:

W 表示向上行动
A 表示向左行动
S 表示向下行动
D 表示向右行动
他想知道，机器人执行完所有指令后，能摘到多少星星。

输入格式

第一行，两个数 n,m 用空格隔开，分别表示地图的长与宽。

第二行，一个整数 k 表示星星的总个数。

接下来 k 行，每行两个数x,y表示坐标(x,y)处有星星。(1≤x≤n,1≤y≤m)

接下来 11 行，一个数t表示有t条指令。

接下来 t 行，每行一个字符加一个整数。字符表示方向，整数表示步数。

注：

一个相同位置 (x,y) 可能出现不止一次，但是，此位置只有一个星星。
星星在摘完一次后，就会消失。也就是说，同一个位置经过多次，只有第一次能收集到星星。
保证机器人不会走出地图范围。

输出格式

输出一行，一个数表示收集到的星星个数。

解法

暴力即可得80分，剩下的20分看优化：

为避免机器人一次运动距离过长造成若干冗余循环，我们可以在每一行与每一列设置一个监视器，如果这一行或者这一列没有星星了我们就将监视器置1，每次机器人行动之前先看监视器，如果为1则直接移动到目标位置而不用遍历。

代码

#include <bits/stdc++.h>
using namespace std;

bool xTrack[10010];//行监视器
bool yTrack[10010];//列监视器
bool Map[10010][10010];//地图，记录星星位置

int main()
{
    int n, m, k;
    cin >> n >> m >> k;
    while (k--)
    {
        int x, y;
        cin >> x >> y;
        Map[x][y] = 1;
    }
    int xCur = 1, yCur = 1;//当前坐标为(xCur, yCur)
    int t;//操作数量
    int sum = 0;
    cin >> t;
    while (t--)
    {
        char _dir;
        int dis;
        cin >> _dir >> dis;
        if (_dir == 'W')
        {
            if (yTrack[yCur])
            {
                xCur -= dis;//直接移动到目标位置然后跳过循环
                continue;
            }
            for (int i = xCur; i >= xCur - dis; --i)
            {//遍历一遍
                if (Map[i][yCur])
                {
                    sum++;
                    Map[i][yCur] = 0;
                }
            }
            bool flag = 0;
            for (int i = 1; i <= n; ++i)
            {//维护监视器
                if (Map[i][yCur])
                {
                    flag = 1;
                    break;
                }
            }
            if (!flag)
                yTrack[yCur] = 1;
            xCur -= dis;
            continue;
        }
//以下同上
        else if (_dir == 'A')
        {
            if (xTrack[xCur])
            {
                yCur -= dis;
                continue;
            }
            for (int i = yCur; i >= yCur - dis; --i)
            {
                if (Map[xCur][i])
                {
                    sum++;
                    Map[xCur][i] = 0;
                }
            }
            bool flag = 0;
            for (int i = 1; i <= m; ++i)
            {
                if (Map[xCur][i])
                {
                    flag = 1;
                    break;
                }
            }
            if (!flag)
                xTrack[xCur] = 1;
            yCur -= dis;
            continue;
        }

        else if (_dir == 'S')
        {
            if (yTrack[yCur])
            {
                xCur += dis;
                continue;
            }
            for (int i = xCur; i <= xCur + dis; ++i)
            {
                if (Map[i][yCur])
                {
                    sum++;
                    Map[i][yCur] = 0;
                }
            }
            bool flag = 0;
            for (int i = 1; i <= n; ++i)
            {
                if (Map[i][yCur])
                {
                    flag = 1;
                    break;
                }
            }
            if (!flag)
                yTrack[yCur] = 1;
            xCur += dis;
            continue;
        }

        else if (_dir == 'D')
        {
            if (xTrack[xCur])
            {
                yCur += dis;
                continue;
            }
            for (int i = yCur; i <= yCur + dis; ++i)
            {
                if (Map[xCur][i])
                {
                    sum++;
                    Map[xCur][i] = 0;
                }
            }
            bool flag = 0;
            for (int i = 1; i <= m; ++i)
            {
                if (Map[xCur][i])
                {
                    flag = 1;
                    break;
                }
            }
            if (!flag)
                xTrack[xCur] = 1;
            yCur += dis;
            continue;
        }
    }

    cout << sum << endl;
}