/*
做完这题我打算看《海底总动员》Demo Demo好可爱
用广搜过的, 主要思路如下:
(1)首先是建图, 由于输入给的都是线段, 但是我们平常处理这类问题都是转换为网格来做的, 因此需要
将线段转换为网格.转化的方法是对于每个格子,用其左上角点的坐标来表示这个格子,如果其左上角点的
坐标是[i][j],那么这个格子就表示为[i][j].将其四周边界的四条线段归这个格子管.即为每个格子建一
个数组round[i][j][4],第三维的四个位置分别表示这四条线段的类型: 0表示空气,1表示墙,2表示是一扇
门,这样这个模型就建立好了.
(2)其次是bfs的起始点选为Nemo所在的位置,注意要将这个浮点点位置转化为格子的坐标.转化的方法很简
单.对于x坐标取整即可,对于y坐标取整+1即可,比如Nemo所在位置为[1.2, 1.3]那么转化为格子的坐标即为:
[1, 2].这个坐标即位bfs遍历的起始点
(3)遍历的时候如果所走的方向是墙,则不可走.如果是门则将当前总的steps数+1,如果为空气,steps数不变.
另外一点就是如何判重.判重不能简单地记录有没有被访问过,而是需要记录到当前格子的最小步骤.如果当
前总步骤数小于当前格子的最小步骤数,则更新其最小步骤数并将这个格子加入队列中.
(4)遍历的终止位置即为题目中的出发位置[0, 0]
*/
#include <iostream>
#include <queue>
#define MAX_N 210 //最大限度边界
using namespace std;
int v[MAX_N + 1][MAX_N + 1]; //v[i][j]表示到格子[i][j]的最小步骤数
int round[MAX_N + 1][MAX_N + 1][4]; //记录当前格子四面边界的类型, 0:air 1:wall 2:door
int wn, dn, startXI, startYI, minSteps; //wn:墙的数目,dn:门的数目,起始点对应的格子坐标
double startXF, startYF; //起始点的输入浮点坐标
int dirarray[4][2] = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}}; //方向数组,走四个方向对坐标的变化
//上:0, 下:1, 左:2, 右:3
//入bfs队列的元素类型
struct elem
{
//x, y记录这个格子的坐标; dir记录是从当前格子的哪个方向进入这个格子的,上:0, 下:1, 左:2, 右:3
int x, y, dir, stepnum;
//stepnum记录到达当前格子所需的步骤数
};
queue<elem> bfsq; //bfs的队列
//取当前方向的对面方向
void changeDir(int orgignal, int &newDir)
{
if(orgignal == 0) newDir = 1;
else if(orgignal == 1) newDir = 1;
else if(orgignal == 2) newDir = 3;
else newDir = 2;
}
//当断当前坐标是否在合法范围内
bool inRange(int x, int y)
{
return x >= 0 && x <= 205 && y >= 0 && y <= 205;
}
void bfs()
{
//将Demo的位置入队列作为bfs的起始位置
while(!bfsq.empty()) bfsq.pop();
elem curelem, newelem;
curelem.x = startXI; curelem.y = startYI; curelem.dir = -1; curelem.stepnum = 0;
v[startXI][startYI] = 0;
bfsq.push(curelem);
int curx, cury, curdir, cursteps, newx, newy, newdir, newsteps, d;
while(!bfsq.empty())
{
curelem = bfsq.front();
bfsq.pop();
curx = curelem.x; cury = curelem.y; curdir = curelem.dir; cursteps = curelem.stepnum;
//到达出发点
if(curx == 0 && cury == 0)
{
//更新所需位置的最优值
if(cursteps < minSteps)
minSteps = cursteps;
continue;
}
//遍历当前格子的四个方向,尝试往这四个方向走
for(d = 0; d < 4; d++)
{
//不能往回走
if(d != curdir)
{
//所走方向不能是墙
if(round[curx][cury][d] != 1)
{
//得到新的格子坐标
newx = curx + dirarray[d][0];
newy = cury + dirarray[d][1];
//新坐标在合法范围内
if(inRange(newx, newy))
{
//计算所有方向相对目标格子所在的方位
changeDir(d, newdir);
//门,步骤数+1
if(round[curx][cury][d] == 2)
newsteps = cursteps + 1;
else //空气,步骤数不变
newsteps = cursteps;
//判断这个新格子的新状态是否需要入队列
if((v[newx][newy] == 0xbf || newsteps < v[newx][newy]) && newsteps < minSteps)
{
v[newx][newy] = newsteps;
newelem.x = newx; newelem.y = newy; newelem.stepnum = newsteps; newelem.dir = newdir;
bfsq.push(newelem);
}
}
}
}
}
}
}
int main()
{
int i, j, x, y, d, t;
while(scanf("%d%d", &wn, &dn) && !(wn == -1 && dn == -1))
{
minSteps = INT_MAX;
memset(v, 12, sizeof(v));
memset(round, 0, sizeof(round));
for(i = 1; i <= wn; i++)
{
scanf("%d%d%d%d", &x, &y, &d, &t);
//输入的预处理,将线段(墙)转换为相应格子对应的四面边界
if(d == 1)
for(j = y + 1; j <= y + t; j++)
round[x][j][2] = round[x - 1][j][3] = 1;
else
for(j = x; j < x + t; j++)
round[j][y][0] = round[j][y + 1][1] = 1;
}
for(i = 1; i <= dn; i++)
{
scanf("%d%d%d", &x, &y, &d);
//输入的预处理,将线段(门)转换为相应格子的四面边界方向
if(d == 1)
round[x][y + 1][2] = round[x - 1][y + 1][3] = 2;
else
round[x][y][0] = round[x][y + 1][1] = 2;
}
scanf("%lf%lf", &startXF, &startYF);
//将Demo的位置转换为格子坐标
startXI = startXF;
startYI = startYF + 1;
//题目中的异常数据
if(startXI < 0 || startXI > 199 || startYI < 0 || startYI > 199)
printf("0/n");
else
{
bfs();
if(minSteps == INT_MAX) printf("-1/n");
else printf("%d/n", minSteps);
}
}
return 0;
}