HDU 4444 - Walk

题目地址：　http://acm.hdu.edu.cn/showproblem.php?pid=4444

2012年ACMICPC金华赛区C题。

作为我们队主攻搜索和数据结构（线段树神马的经常接触离散化），当时我一看这题就有想法了，综合起来只敲了四十多分钟。（其间分身去把被卡了N久的水题A了）

我们队就是靠这题从铁直接飞到银牌。

思路很简单。

离散化边界为点。然后就是用普通的BFS去做。

需要储存每个边的四种状态：矩形上边界？矩形下边界？矩形左边界？矩形右边界？

边拐角的问题不同于角拐角，有六种可能，比较难解决，需要多一想一想。

比较难通过的是我附录的最后一组测试数据。

当时比赛时犯2，判断以EOF结束，WA了两次。。。 没想到，回来之后在HDU交，还是犯2，又判断以EOF结束，再WA两次。。。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<queue>

using namespace std;

int x[110],y[110];
int idx[110],idy[110];
int mp[210][210],path[210][210];
bool UP[210][210],DOWN[210][210],LEFT[210][210],RIGHT[210][210];
int ax,ay,bx,by;
int n,nn;
int mx,my;

struct QUE
{
int x,y;
QUE()
{

}
QUE(int xx,int yy)
{
x=xx,y=yy;
}
}que[200000];

int fx[]={1,0,0,-1,0,0,0,0,1,-1,1,-1};
int fy[]={0,1,-1,0,1,-1,1,-1,0,0,0,0};
int fz[]={0,0,0,0,1,1,-1,-1,-1,-1,1,1};

void turn(int ex,int ey,int rx,int ry,int &t,int p)
{
int i,nx,ny;
for(i=1;;i+=2)
{
nx=rx+ex*i;
ny=ry+ey*i;
if(nx<0 || ny<0 || nx>mx || ny>my)
{
return;
}
if(mp[nx][ny]>0)
{
return;
}
if(i>1 &&(UP[nx-ex][ny-ey]&&DOWN[nx-ex][ny-ey]&&(ny&1) || (nx&1)&&LEFT[nx-ex][ny-ey]&&RIGHT[nx-ex][ny-ey]))
{
return;
}
if(path[nx][ny]==-1)
{
que[++t]=QUE(nx,ny);
path[nx][ny]=p;
}
else if(path[nx][ny]<p)
{
return;
}
}
}

int bfs()
{
int s,t,k;
int rx,ry;
s=0;
t=-1;
for(k=0;k<4;k++)
{
turn(fx[k],fy[k],ax,ay,t,0);
}
while(s<=t)
{
rx=que[s].x;
ry=que[s].y;
++s;
for(k=0;k<4;k++)
{
if(rx+fx[k]==bx && ry+fy[k]==by)
{
return path[rx][ry];
}
}
if(rx&1)
{
for(k=4;k<8;k++)
{
if(UP[rx+fz[k]][ry]&&DOWN[rx+fz[k]][ry] || LEFT[rx+fz[k]][ry]&&RIGHT[rx+fz[k]][ry])
{
if(fy[k]<0 && RIGHT[rx][ry] || fy[k]>0 && LEFT[rx][ry])
{
continue;
}
}
turn(fx[k],fy[k],rx+fz[k],ry,t,path[rx][ry]+1);
}
}
else
{
for(k=8;k<12;k++)
{
if(UP[rx][ry+fz[k]]&&DOWN[rx][ry+fz[k]] || LEFT[rx][ry+fz[k]]&&RIGHT[rx][ry+fz[k]])
{
if(fx[k]<0 && UP[rx][ry] || fx[k]>0 && DOWN[rx][ry])
{
continue;
}
}
turn(fx[k],fy[k],rx,ry+fz[k],t,path[rx][ry]+1);
}
}
}
return -1;
}

int cmpx(int a,int b)
{
return x[a]<x[b];
}

int cmpy(int a,int b)
{
return y[a]<y[b];
}

void discretization()
{
int i,tmp,now;
nn+=2;
for(i=0;i<nn;i++)
{
idx[i]=idy[i]=i;
}
sort(idx,idx+nn,cmpx);
sort(idy,idy+nn,cmpy);

tmp=-1000000000;
now=0;
for(i=0;i<nn;i++)
{
if(x[idx[i]]!=tmp)
{
tmp=x[idx[i]];
now+=2;
}
x[idx[i]]=now;
}
mx=now+2;
tmp=-1000000000;
now=0;
for(i=0;i<nn;i++)
{
if(y[idy[i]]!=tmp)
{
tmp=y[idy[i]];
now+=2;
}
y[idy[i]]=now;
}
my=now+2;
/*
cout<<"离散化结果： "<<endl;
cout<<"x:   "; for(i=0;i<nn;i++) cout<<x[idx[i]]<<" ";cout<<endl;
cout<<"y:   "; for(i=0;i<nn;i++) cout<<y[idy[i]]<<" ";cout<<endl;
*/
nn-=2;
ax=x[nn];
ay=y[nn];
bx=x[nn+1];
by=y[nn+1];
}

void INIT()
{
int i,j,k;
memset(mp,0,sizeof(mp));
memset(path,-1,sizeof(path));
memset(UP,0,sizeof(UP));
memset(DOWN,0,sizeof(DOWN));
memset(LEFT,0,sizeof(LEFT));
memset(RIGHT,0,sizeof(RIGHT));
for(i=0;i<n;i++)
{
for(j=x[i]+1;j<x[i+n];j++)
{
mp[j][y[i]+1]=mp[j][y[i+n]-1]=1;
}
for(j=y[i]+1;j<y[i+n];j++)
{
mp[x[i]+1][j]=mp[x[i+n]-1][j]=1;
}
for(j=x[i];j<=x[i+n];j++)
{
LEFT[j][y[i]]=true;
RIGHT[j][y[i+n]]=true;
}
for(j=y[i];j<=y[i+n];j++)
{
DOWN[x[i]][j]=true;
UP[x[i+n]][j]=true;
}
}
/*
cout<<"打印地图:"<<endl;
for(j=my-1;j>=0;j--)
{
for(i=0;i<mx;i++)
{ // 2表示两点之间有不可走的边， 1表示两点之间有可走的边 , 0表示两点之间无边， .表示整数坐标点
if(i%2==0 && j%2==0) cout<<". ";
else if(i%2==1 && j%2==1) cout<<"  ";
else if(mp[i][j] || UP[i][j]&&DOWN[i][j] || LEFT[i][j]&&RIGHT[i][j]) cout<<"2 ";
else cout<<(UP[i][j]||DOWN[i][j]||LEFT[i][j]||RIGHT[i][j])<<" ";
}
cout<<endl;
}
*/
}

int input()
{
int i;
int X1,X2,Y1,Y2;
scanf("%d%d%d%d",&ax,&ay,&bx,&by);
if(ax==0 && bx==0 && ay==0 && by==0)
{
return 0;
}
scanf("%d",&n);
nn=n+n;
for(i=0;i<n;i++)
{
scanf("%d%d%d%d",&X1,&Y1,&X2,&Y2);
x[i]=min(X1,X2);
x[i+n]=max(X1,X2);
y[i]=min(Y1,Y2);
y[i+n]=max(Y1,Y2);
}
x[nn]=ax;
x[nn+1]=bx;
y[nn]=ay;
y[nn+1]=by;
return 1;
}

int main()
{

while(input())
{
discretization();
if(ax==bx && ay==by)
{
puts("0");
continue;
}
INIT();
printf("%d\n",bfs());
/*
cout<<"打印路径："<<endl;
for(int i=my;i>=0;i--)
{
for(int j=0;j<mx;j++)
{
printf("%3d",path[j][i]);
}
cout<<endl;
}
*/
}
return 0;
}

/*

// 绕路   2
1 1 1 4
1
0 2 2 3

// 直走  0
1 1 1 4
1
3 3 4 5

// 沿着边直走  0
0 1 0 7
2
0 2 2 3
-1 4 0 5

// 沿着边直走  0
0 1 0 7
2
0 2 2 3
0 3 2 4

// 无法穿过缝隙，绕路   2
0 1 0 7
2
0 2 2 3
-1 3 0 5

// 无法到达  -1
0 0 5 5
4
-1 1 1 2
1 -1 2 1
-1 -1 1 -2
-1 1 -2 -1

// 同点经过两次。  5
1 3 4 1
10
-1 -1 3 2
3 -1 7 0
7 -1 11 3
9 3 11 7
-1 7 11 9
0 5 4 7
-1 2 0 7
2 2 4 3
4 3 5 4
5 4 8 6

*/