NOI: 寻找Nemo

一、题目大意

二、解题思路

使用grad[x][y][4]表示每个格每个方向的状况，然后使用广搜。逆向思考，把被困者看作起点，目的是走出迷宫。

三、代码

• 不明白为什么RE了，感觉没错。。

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

const int MAX = 300;
const int LEFT = 0;
const int DOWN = 1;
const int RIGHT = 2;
const int UP = 3;
const int inf = 1 << 20;

int grad[MAX][MAX][4];
int T[MAX][MAX];
struct Node
{
    int x, y, t;
    bool operator < (const Node &A)const
    {
        return t > A.t;
    }
};
priority_queue<Node>Q;
int L, D, R, U;

int dir[4][2] = {{0,-1},{-1,0},{0,1},{1,0}};

int bfs(int sx, int sy)
{
    for(int i=0; i<MAX; i++)
        for(int j=0; j<MAX; j++)
            T[i][j] = inf;

    while(!Q.empty())
        Q.pop();

    T[sx][sy] = 1;
    Q.push((Node){sx, sy, 1});
    int x, y;
    while(!Q.empty())
    {
        Node top = Q.top(); Q.pop();

        x = top.x; y = top.y;
        if(x < L || y > R || x < D || y > U)
            return top.t-1;

        for(int i=0; i<4; i++)
        {
            if(grad[x][y][i]==1)
                continue;

            int nx = x + dir[i][0];
            int ny = y + dir[i][1];
            int next_t = top.t + (grad[x][y][i] == 2);

            if(next_t >= T[nx][ny])
                continue;

            T[nx][ny] = next_t;
            Q.push((Node){nx, ny, next_t});

        }
    }
    return -1;


}
int main()
{
    int M, N;
    while(cin >> M >> N)
    {
        if(M == -1 && N == -1)
            break;

        memset(grad,0,sizeof(grad));

        D = L = inf; U = R = -inf;
        int x, y, d, t;
        while(M--)
        {
            cin >> x >> y >> d >> t;
            if(d)
            {
                for(int i=y; i<y+t; i++)
                    grad[i][x-1][RIGHT] = grad[i][x][LEFT] = 1;
                D = min(D, y);
                U = max(U, y+t);
                L = min(L, x);
                R = max(R, x);
            }
            else
            {
                for(int i=x; i<x+t; i++)
                    grad[y-1][i][UP] = grad[y][i][DOWN] = 1;
                D = min(D, y);
                U = max(U, y);
                L = min(L, x);
                R = max(R, x+t);
            }
        }
        while(N--)
        {
            cin >> x >> y >> d;
            if(d)
            {
                grad[y][x-1][RIGHT] = grad[y][x][LEFT] = 2;
                D = min(D, y);
                U = max(U, y);
                L = min(L, x);
                R = max(R, x);
            }
            else
            {

                grad[y-1][x][UP] = grad[y][x][DOWN] = 2;
                D = min(D, y);
                U = max(U, y);
                L = min(L, x);
                R = max(R, x);
            }
        }

        double f1, f2;
        cin >> f1 >> f2;
        int sx, sy;
        sx = (int)f1;
        sy = (int)f2;

        if(sx < L || sy >= R || sx < D || sy >= U)
        {
            cout << 0 << endl;
            continue;
        }

        int ans = bfs(sx, sy);

        cout << ans << endl;
    }
    return 0;
}